@contentful/field-editor-shared 2.11.2 → 2.12.1

package/dist/cjs/LocalePublishingEntityStatusBadge/LocalePublishingPopover.js

@@ -262,7 +262,8 @@ function LocalePublishingPopover({ entity, jobs, isScheduled, localesStatusMap,
         tabIndex: 0,
         onFocus: ()=>setIsOpen(true),
         onBlur: ()=>setIsOpen(false),
-        endIcon: /*#__PURE__*/ _react.default.createElement(_f36icons.ArrowDownIcon, {
+        endIcon: /*#__PURE__*/ _react.default.createElement(_f36icons.CaretDownIcon, {
+            size: "tiny",
             color: getIconColor(entityStatus)
         }),
         onMouseOver: onMouseEnter,

package/dist/cjs/ReleaseEntityStatusBadge/ReleaseEntityStatusPopover.js

@@ -233,7 +233,8 @@ function ReleaseEntityStatusPopover({ releaseLocalesStatusMap, activeLocales, is
         variant: _constants.RELEASE_BADGES[status.primary].variant,
         onFocus: ()=>setIsOpen(true),
         onBlur: ()=>setIsOpen(false),
-        endIcon: /*#__PURE__*/ _react.default.createElement(_f36icons.ArrowDownIcon, {
+        endIcon: /*#__PURE__*/ _react.default.createElement(_f36icons.CaretDownIcon, {
+            size: "tiny",
             color: _constants.RELEASE_BADGES[status.primary].icon
         }),
         onMouseOver: onMouseEnter,

package/dist/cjs/hooks/useActiveReleaseLocalesStatuses.js

@@ -9,22 +9,25 @@ Object.defineProperty(exports, "useActiveReleaseLocalesStatuses", {
     }
 });
 const _react = require("react");
-const _getPreviousReleaseEntryVersion = require("../utils/getPreviousReleaseEntryVersion");
-const useActiveReleaseLocalesStatuses = ({ currentEntryDraft, entryId, releaseVersionMap, locales, activeRelease, releases })=>{
-    const previousReleaseEntity = (0, _react.useMemo)(()=>(0, _getPreviousReleaseEntryVersion.getPreviousReleaseEntryVersion)({
-            entryId,
+const _getPreviousReleaseEntity = require("../utils/getPreviousReleaseEntity");
+const useActiveReleaseLocalesStatuses = ({ currentEntityDraft, entityId, entityType, releaseVersionMap, locales, activeRelease, releases })=>{
+    const previousReleaseEntity = (0, _react.useMemo)(()=>(0, _getPreviousReleaseEntity.getPreviousReleaseEntity)({
+            entityId,
+            entityType,
             releaseVersionMap,
             activeRelease,
             releases
         }).previousReleaseEntity, [
-        entryId,
+        entityId,
+        entityType,
         releaseVersionMap,
         activeRelease,
         releases
     ]);
-    const activeReleaseReleaseEntity = (0, _react.useMemo)(()=>activeRelease?.entities.items.find((entity)=>entity.entity.sys.id === entryId), [
+    const activeReleaseReleaseEntity = (0, _react.useMemo)(()=>activeRelease?.entities.items.find((entity)=>entity.entity.sys.id === entityId && entity.entity.sys.linkType === entityType), [
         activeRelease?.entities.items,
-        entryId
+        entityId,
+        entityType
     ]);
     const getLocaleStatus = (0, _react.useCallback)((localeCode)=>{
         if (!activeReleaseReleaseEntity) {
@@ -52,8 +55,8 @@ const useActiveReleaseLocalesStatuses = ({ currentEntryDraft, entryId, releaseVe
                 return acc;
             }
             if (getLocaleStatus(locale.code) === 'draft') {
-                if (currentEntryDraft?.sys.fieldStatus) {
-                    const previousStatus = currentEntryDraft.sys.fieldStatus['*'][locale.code];
+                if (currentEntityDraft?.sys.fieldStatus) {
+                    const previousStatus = currentEntityDraft.sys.fieldStatus['*'][locale.code];
                     if (previousStatus === 'published' || previousStatus === 'changed') {
                         acc.set(locale.code, {
                             status: 'becomesDraft',
@@ -100,7 +103,7 @@ const useActiveReleaseLocalesStatuses = ({ currentEntryDraft, entryId, releaseVe
         locales,
         activeReleaseReleaseEntity,
         getLocaleStatus,
-        currentEntryDraft?.sys.fieldStatus,
+        currentEntityDraft?.sys.fieldStatus,
         previousReleaseEntity
     ]);
     return {

package/dist/cjs/hooks/useActiveReleaseLocalesStatuses.spec.js

@@ -3,10 +3,12 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 const _react = require("@testing-library/react");
-const _getPreviousReleaseEntryVersion = require("../utils/getPreviousReleaseEntryVersion");
+const _getPreviousReleaseEntity = require("../utils/getPreviousReleaseEntity");
 const _useActiveReleaseLocalesStatuses = require("./useActiveReleaseLocalesStatuses");
-const buildEntry = (status)=>({
+const buildEntry = (status, id = 'entry-1')=>({
         sys: {
+            id,
+            type: 'Entry',
             fieldStatus: {
                 '*': {
                     'en-US': status
@@ -14,17 +16,28 @@ const buildEntry = (status)=>({
             }
         }
     });
-const createEntryBasedReleaseEntity = ({ entryId = 'entry-1', action = 'publish' })=>({
+const buildAsset = (status, id = 'asset-1')=>({
+        sys: {
+            id,
+            type: 'Asset',
+            fieldStatus: {
+                '*': {
+                    'en-US': status
+                }
+            }
+        }
+    });
+const createEntryBasedReleaseEntity = ({ entityId = 'entry-1', action = 'publish', entityType = 'Entry' })=>({
         entity: {
             sys: {
                 type: 'Link',
-                linkType: 'Entry',
-                id: entryId
+                linkType: entityType,
+                id: entityId
             }
         },
         action
     });
-const createEntryBasedRelease = ({ entryId, action } = {})=>({
+const createEntryBasedRelease = ({ entityId, action, entityType = 'Entry' } = {})=>({
         title: 'Release 1',
         sys: {
             id: 'release-1',
@@ -34,18 +47,19 @@ const createEntryBasedRelease = ({ entryId, action } = {})=>({
         entities: {
             items: [
                 createEntryBasedReleaseEntity({
-                    entryId,
-                    action
+                    entityId,
+                    action,
+                    entityType
                 })
             ]
         }
     });
-const createLocaleBasedReleaseEntity = ({ entryId = 'entry-1', verb = 'add' })=>({
+const createLocaleBasedReleaseEntity = ({ entityId = 'entry-1', verb = 'add', entityType = 'Entry' })=>({
         entity: {
             sys: {
                 type: 'Link',
-                linkType: 'Entry',
-                id: entryId
+                linkType: entityType,
+                id: entityId
             }
         },
         [verb]: {
@@ -56,7 +70,7 @@ const createLocaleBasedReleaseEntity = ({ entryId = 'entry-1', verb = 'add' })=>
             }
         }
     });
-const createLocaleBasedRelease = ({ entryId, verb } = {})=>({
+const createLocaleBasedRelease = ({ entityId, verb, entityType = 'Entry' } = {})=>({
         title: 'Release 1',
         sys: {
             id: 'release-1',
@@ -66,263 +80,240 @@ const createLocaleBasedRelease = ({ entryId, verb } = {})=>({
         entities: {
             items: [
                 createLocaleBasedReleaseEntity({
-                    entryId,
-                    verb
+                    entityId,
+                    verb,
+                    entityType
                 })
             ]
         }
     });
-jest.mock('../utils/getPreviousReleaseEntryVersion', ()=>({
-        getPreviousReleaseEntryVersion: jest.fn()
+jest.mock('../utils/getPreviousReleaseEntity', ()=>({
+        getPreviousReleaseEntity: jest.fn()
     }));
-const baseParams = {
-    entryId: 'entry-1',
-    locales: [
-        {
-            code: 'en-US'
-        }
-    ],
-    isActiveReleaseLoading: false,
-    releaseVersionMap: new Map(),
-    releases: {
-        items: []
-    }
-};
+const ENTITY_TYPES = [
+    'Entry',
+    'Asset'
+];
 describe('useActiveReleaseLocalesStatuses', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
     });
-    describe('with entry based publishing', ()=>{
-        it('returns Will publish status when active release has publish action', ()=>{
-            _getPreviousReleaseEntryVersion.getPreviousReleaseEntryVersion.mockReturnValue({
-                previousReleaseEntity: createEntryBasedReleaseEntity({
-                    entryId: 'entry-1',
-                    action: 'unpublish'
-                }),
-                previousEntryVersion: {
-                    sys: {
-                        fieldStatus: {
-                            '*': {
-                                'en-US': 'draft'
-                            }
-                        }
-                    }
-                }
-            });
-            const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
-                    ...baseParams,
-                    activeRelease: createEntryBasedRelease(),
-                    currentEntryDraft: buildEntry('draft')
-                }));
-            expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
-                variant: 'positive',
-                status: 'willPublish',
-                label: 'Will publish',
-                locale: {
+    ENTITY_TYPES.forEach((entityType)=>{
+        const entityId = entityType === 'Entry' ? 'entry-1' : 'asset-1';
+        const baseParams = {
+            entityId,
+            entityType,
+            locales: [
+                {
                     code: 'en-US'
                 }
-            });
-        });
-        it('returns Becomes draft status when previous version has published locales and active version has unpublish action', ()=>{
-            _getPreviousReleaseEntryVersion.getPreviousReleaseEntryVersion.mockReturnValue({
-                previousReleaseEntity: createEntryBasedReleaseEntity({
-                    entryId: 'entry-1',
-                    action: 'publish'
-                }),
-                previousEntryVersion: {
-                    sys: {
-                        fieldStatus: {
-                            '*': {
-                                'en-US': 'published'
-                            }
-                        }
+            ],
+            isActiveReleaseLoading: false,
+            releaseVersionMap: new Map(),
+            releases: {
+                items: []
+            }
+        };
+        describe(`${entityType} with entry based publishing`, ()=>{
+            it('returns Will publish status when active release has publish action', ()=>{
+                _getPreviousReleaseEntity.getPreviousReleaseEntity.mockReturnValue({
+                    previousReleaseEntity: createEntryBasedReleaseEntity({
+                        entityId,
+                        action: 'unpublish',
+                        entityType
+                    })
+                });
+                const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
+                        ...baseParams,
+                        activeRelease: createEntryBasedRelease({
+                            entityId,
+                            entityType
+                        }),
+                        currentEntityDraft: entityType === 'Entry' ? buildEntry('draft') : buildAsset('draft')
+                    }));
+                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                    variant: 'positive',
+                    status: 'willPublish',
+                    label: 'Will publish',
+                    locale: {
+                        code: 'en-US'
                     }
-                }
-            });
-            const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
-                    ...baseParams,
-                    activeRelease: createEntryBasedRelease({
-                        action: 'unpublish'
-                    }),
-                    currentEntryDraft: buildEntry('published')
-                }));
-            expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
-                variant: 'warning',
-                status: 'becomesDraft',
-                label: 'Becomes draft',
-                locale: {
-                    code: 'en-US'
-                }
+                });
             });
-        });
-        it('returns Remains draft status when previous version has draft locales and active version has unpublish action', ()=>{
-            _getPreviousReleaseEntryVersion.getPreviousReleaseEntryVersion.mockReturnValue({
-                previousReleaseEntity: createEntryBasedReleaseEntity({
-                    action: 'unpublish'
-                }),
-                previousEntryVersion: {
-                    sys: {
-                        fieldStatus: {
-                            '*': {
-                                'en-US': 'draft'
-                            }
-                        }
+            it('returns Becomes draft status when previous version has published locales and active version has unpublish action', ()=>{
+                _getPreviousReleaseEntity.getPreviousReleaseEntity.mockReturnValue({
+                    previousReleaseEntity: createEntryBasedReleaseEntity({
+                        entityId,
+                        action: 'publish',
+                        entityType
+                    })
+                });
+                const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
+                        ...baseParams,
+                        activeRelease: createEntryBasedRelease({
+                            action: 'unpublish',
+                            entityId,
+                            entityType
+                        }),
+                        currentEntityDraft: entityType === 'Entry' ? buildEntry('published') : buildAsset('published')
+                    }));
+                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                    variant: 'warning',
+                    status: 'becomesDraft',
+                    label: 'Becomes draft',
+                    locale: {
+                        code: 'en-US'
                     }
-                }
-            });
-            const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
-                    ...baseParams,
-                    activeRelease: createEntryBasedRelease({
-                        action: 'unpublish'
-                    }),
-                    currentEntryDraft: buildEntry('draft')
-                }));
-            expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
-                variant: 'secondary',
-                status: 'remainsDraft',
-                label: 'Remains draft',
-                locale: {
-                    code: 'en-US'
-                }
+                });
             });
-        });
-        it('returns Not in release status when entry is not in the release', ()=>{
-            _getPreviousReleaseEntryVersion.getPreviousReleaseEntryVersion.mockReturnValue({
-                previousReleaseEntity: undefined,
-                previousEntryVersion: undefined
-            });
-            const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
-                    ...baseParams,
-                    activeRelease: createEntryBasedRelease({
-                        entryId: 'entry-2',
-                        action: 'publish'
-                    }),
-                    currentEntryDraft: buildEntry('draft')
-                }));
-            expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
-                variant: 'secondary',
-                status: 'notInRelease',
-                label: 'Not in release',
-                locale: {
-                    code: 'en-US'
-                }
-            });
-        });
-    });
-    describe('with locale based publishing', ()=>{
-        it('returns Will publish status when active release has publish action', ()=>{
-            _getPreviousReleaseEntryVersion.getPreviousReleaseEntryVersion.mockReturnValue({
-                previousReleaseEntity: createLocaleBasedReleaseEntity({
-                    entryId: 'entry-1',
-                    verb: 'remove'
-                }),
-                previousEntryVersion: {
-                    sys: {
-                        fieldStatus: {
-                            '*': {
-                                'en-US': 'draft'
-                            }
-                        }
+            it('returns Remains draft status when previous version has draft locales and active version has unpublish action', ()=>{
+                _getPreviousReleaseEntity.getPreviousReleaseEntity.mockReturnValue({
+                    previousReleaseEntity: createEntryBasedReleaseEntity({
+                        action: 'unpublish',
+                        entityType,
+                        entityId
+                    })
+                });
+                const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
+                        ...baseParams,
+                        activeRelease: createEntryBasedRelease({
+                            action: 'unpublish',
+                            entityId,
+                            entityType
+                        }),
+                        currentEntityDraft: entityType === 'Entry' ? buildEntry('draft') : buildAsset('draft')
+                    }));
+                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                    variant: 'secondary',
+                    status: 'remainsDraft',
+                    label: 'Remains draft',
+                    locale: {
+                        code: 'en-US'
                     }
-                }
-            });
-            const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
-                    ...baseParams,
-                    activeRelease: createLocaleBasedRelease(),
-                    currentEntryDraft: buildEntry('draft')
-                }));
-            expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
-                variant: 'positive',
-                status: 'willPublish',
-                label: 'Will publish',
-                locale: {
-                    code: 'en-US'
-                }
+                });
             });
-        });
-        it('returns Becomes draft status when previous version has published locales and active version has unpublish action', ()=>{
-            _getPreviousReleaseEntryVersion.getPreviousReleaseEntryVersion.mockReturnValue({
-                previousReleaseEntity: createLocaleBasedReleaseEntity({
-                    entryId: 'entry-1',
-                    verb: 'add'
-                }),
-                previousEntryVersion: {
-                    sys: {
-                        fieldStatus: {
-                            '*': {
-                                'en-US': 'published'
-                            }
-                        }
+            it('returns Not in release status when entity is not in the release', ()=>{
+                _getPreviousReleaseEntity.getPreviousReleaseEntity.mockReturnValue({
+                    previousReleaseEntity: undefined
+                });
+                const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
+                        ...baseParams,
+                        activeRelease: createEntryBasedRelease({
+                            entityId: entityType === 'Entry' ? 'entry-2' : 'asset-2',
+                            action: 'publish',
+                            entityType
+                        }),
+                        currentEntityDraft: entityType === 'Entry' ? buildEntry('draft') : buildAsset('draft')
+                    }));
+                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                    variant: 'secondary',
+                    status: 'notInRelease',
+                    label: 'Not in release',
+                    locale: {
+                        code: 'en-US'
                     }
-                }
-            });
-            const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
-                    ...baseParams,
-                    activeRelease: createLocaleBasedRelease({
-                        verb: 'remove'
-                    }),
-                    currentEntryDraft: buildEntry('published')
-                }));
-            expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
-                variant: 'warning',
-                status: 'becomesDraft',
-                label: 'Becomes draft',
-                locale: {
-                    code: 'en-US'
-                }
+                });
             });
         });
-        it('returns Remains draft status when previous version has draft locales and active version has unpublish action', ()=>{
-            _getPreviousReleaseEntryVersion.getPreviousReleaseEntryVersion.mockReturnValue({
-                previousReleaseEntity: createLocaleBasedReleaseEntity({
-                    verb: 'remove'
-                }),
-                previousEntryVersion: {
-                    sys: {
-                        fieldStatus: {
-                            '*': {
-                                'en-US': 'draft'
-                            }
-                        }
+        describe(`${entityType} with locale based publishing`, ()=>{
+            it('returns Will publish status when active release has publish action', ()=>{
+                _getPreviousReleaseEntity.getPreviousReleaseEntity.mockReturnValue({
+                    previousReleaseEntity: createLocaleBasedReleaseEntity({
+                        entityId,
+                        verb: 'remove',
+                        entityType
+                    })
+                });
+                const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
+                        ...baseParams,
+                        activeRelease: createLocaleBasedRelease({
+                            entityId,
+                            entityType
+                        }),
+                        currentEntityDraft: entityType === 'Entry' ? buildEntry('draft') : buildAsset('draft')
+                    }));
+                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                    variant: 'positive',
+                    status: 'willPublish',
+                    label: 'Will publish',
+                    locale: {
+                        code: 'en-US'
                     }
-                }
+                });
             });
-            const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
-                    ...baseParams,
-                    activeRelease: createLocaleBasedRelease({
-                        verb: 'remove'
-                    }),
-                    currentEntryDraft: buildEntry('draft')
-                }));
-            expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
-                variant: 'secondary',
-                status: 'remainsDraft',
-                label: 'Remains draft',
-                locale: {
-                    code: 'en-US'
-                }
+            it('returns Becomes draft status when previous version has published locales and active version has unpublish action', ()=>{
+                _getPreviousReleaseEntity.getPreviousReleaseEntity.mockReturnValue({
+                    previousReleaseEntity: createLocaleBasedReleaseEntity({
+                        entityId: 'entry-1',
+                        verb: 'add',
+                        entityType
+                    })
+                });
+                const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
+                        ...baseParams,
+                        activeRelease: createLocaleBasedRelease({
+                            verb: 'remove',
+                            entityId,
+                            entityType
+                        }),
+                        currentEntityDraft: entityType === 'Entry' ? buildEntry('published') : buildAsset('published')
+                    }));
+                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                    variant: 'warning',
+                    status: 'becomesDraft',
+                    label: 'Becomes draft',
+                    locale: {
+                        code: 'en-US'
+                    }
+                });
             });
-        });
-        it('returns Not in release status when entry is not in the release', ()=>{
-            _getPreviousReleaseEntryVersion.getPreviousReleaseEntryVersion.mockReturnValue({
-                previousReleaseEntity: undefined,
-                previousEntryVersion: undefined
+            it('returns Remains draft status when previous version has draft locales and active version has unpublish action', ()=>{
+                _getPreviousReleaseEntity.getPreviousReleaseEntity.mockReturnValue({
+                    previousReleaseEntity: createLocaleBasedReleaseEntity({
+                        verb: 'remove',
+                        entityId,
+                        entityType
+                    })
+                });
+                const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
+                        ...baseParams,
+                        activeRelease: createLocaleBasedRelease({
+                            verb: 'remove',
+                            entityId,
+                            entityType
+                        }),
+                        currentEntityDraft: entityType === 'Entry' ? buildEntry('draft') : buildAsset('draft')
+                    }));
+                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                    variant: 'secondary',
+                    status: 'remainsDraft',
+                    label: 'Remains draft',
+                    locale: {
+                        code: 'en-US'
+                    }
+                });
             });
-            const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
-                    ...baseParams,
-                    activeRelease: createLocaleBasedRelease({
-                        entryId: 'entry-2',
-                        verb: 'add'
-                    }),
-                    currentEntryDraft: buildEntry('draft')
-                }));
-            expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
-                variant: 'secondary',
-                status: 'notInRelease',
-                label: 'Not in release',
-                locale: {
-                    code: 'en-US'
-                }
+            it('returns Not in release status when entry is not in the release', ()=>{
+                _getPreviousReleaseEntity.getPreviousReleaseEntity.mockReturnValue({
+                    previousReleaseEntity: undefined
+                });
+                const { result } = (0, _react.renderHook)(()=>(0, _useActiveReleaseLocalesStatuses.useActiveReleaseLocalesStatuses)({
+                        ...baseParams,
+                        activeRelease: createLocaleBasedRelease({
+                            entityId: entityType === 'Entry' ? 'entry-2' : 'asset-2',
+                            entityType,
+                            verb: 'add'
+                        }),
+                        currentEntityDraft: entityType === 'Entry' ? buildEntry('draft') : buildAsset('draft')
+                    }));
+                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                    variant: 'secondary',
+                    status: 'notInRelease',
+                    label: 'Not in release',
+                    locale: {
+                        code: 'en-US'
+                    }
+                });
             });
         });
     });

package/dist/cjs/index.js

@@ -111,7 +111,7 @@ _export_star(require("./hooks/useLocalePublishStatus"), exports);
 _export_star(require("./LocalePublishingEntityStatusBadge"), exports);
 _export_star(require("./ReleaseEntityStatusBadge"), exports);
 _export_star(require("./utils/determineReleaseAction"), exports);
-_export_star(require("./utils/getEntryReleaseStatus"), exports);
+_export_star(require("./utils/getEntityReleaseStatus"), exports);
 _export_star(require("./utils/parseReleaseParameters"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {