@contentful/field-editor-shared 2.11.1 → 2.12.0

package/dist/esm/ReleaseEntityStatusBadge/ReleaseEntityStatusPopover.js

@@ -1,5 +1,6 @@
 import React, { useCallback, useRef, useState } from 'react';
-import { Badge, Flex, generateIcon, Popover, Skeleton } from '@contentful/f36-components';
+import { Badge, Flex, Popover, Skeleton } from '@contentful/f36-components';
+import { ArrowDownIcon } from '@contentful/f36-icons';
 import tokens from '@contentful/f36-tokens';
 import { cx, css } from 'emotion';
 import { RELEASE_BADGES } from './constants';
@@ -153,14 +154,6 @@ export function ReleaseEntityStatusPopover({ releaseLocalesStatusMap, activeLoca
     const status = determineBadgeStatus(releaseLocalesStatusMap, activeLocales);
     const ariaLabel = status.secondary ? 'Multiple statuses' : status.primary;
     const wrapperClass = generateDynamicStyles(status);
-    const ArrowDownIcon = generateIcon({
-        name: 'ArrowDownIcon',
-        viewBox: '0 0 12 20',
-        path: /*#__PURE__*/ React.createElement("path", {
-            d: "M3.03076 8C2.20109 8 1.73228 8.95209 2.23814 9.60971L5.20727 13.4696C5.60757 13.99 6.39223 13.99 6.79252 13.4696L9.76166 9.60971C10.2675 8.95209 9.79871 8 8.96904 8L3.03076 8Z",
-            fill: "currentColor"
-        })
-    });
     if (isLoading) {
         return /*#__PURE__*/ React.createElement(Skeleton.Container, {
             className: styles.skeletonBadge

package/dist/esm/hooks/useActiveReleaseLocalesStatuses.js

@@ -1,20 +1,23 @@
 import { useCallback, useMemo } from 'react';
-import { getPreviousReleaseEntryVersion } from '../utils/getPreviousReleaseEntryVersion';
-export const useActiveReleaseLocalesStatuses = ({ currentEntryDraft, entryId, releaseVersionMap, locales, activeRelease, releases })=>{
-    const previousReleaseEntity = useMemo(()=>getPreviousReleaseEntryVersion({
-            entryId,
+import { getPreviousReleaseEntity } from '../utils/getPreviousReleaseEntity';
+export const useActiveReleaseLocalesStatuses = ({ currentEntityDraft, entityId, entityType, releaseVersionMap, locales, activeRelease, releases })=>{
+    const previousReleaseEntity = useMemo(()=>getPreviousReleaseEntity({
+            entityId,
+            entityType,
             releaseVersionMap,
             activeRelease,
             releases
         }).previousReleaseEntity, [
-        entryId,
+        entityId,
+        entityType,
         releaseVersionMap,
         activeRelease,
         releases
     ]);
-    const activeReleaseReleaseEntity = useMemo(()=>activeRelease?.entities.items.find((entity)=>entity.entity.sys.id === entryId), [
+    const activeReleaseReleaseEntity = useMemo(()=>activeRelease?.entities.items.find((entity)=>entity.entity.sys.id === entityId && entity.entity.sys.linkType === entityType), [
         activeRelease?.entities.items,
-        entryId
+        entityId,
+        entityType
     ]);
     const getLocaleStatus = useCallback((localeCode)=>{
         if (!activeReleaseReleaseEntity) {
@@ -42,8 +45,8 @@ export const useActiveReleaseLocalesStatuses = ({ currentEntryDraft, entryId, re
                 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',
@@ -90,7 +93,7 @@ export const useActiveReleaseLocalesStatuses = ({ currentEntryDraft, entryId, re
         locales,
         activeReleaseReleaseEntity,
         getLocaleStatus,
-        currentEntryDraft?.sys.fieldStatus,
+        currentEntityDraft?.sys.fieldStatus,
         previousReleaseEntity
     ]);
     return {

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

@@ -1,8 +1,10 @@
 import { renderHook } from '@testing-library/react';
-import { getPreviousReleaseEntryVersion } from '../utils/getPreviousReleaseEntryVersion';
+import { getPreviousReleaseEntity } from '../utils/getPreviousReleaseEntity';
 import { useActiveReleaseLocalesStatuses } from './useActiveReleaseLocalesStatuses';
-const buildEntry = (status)=>({
+const buildEntry = (status, id = 'entry-1')=>({
         sys: {
+            id,
+            type: 'Entry',
             fieldStatus: {
                 '*': {
                     'en-US': status
@@ -10,17 +12,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',
@@ -30,18 +43,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]: {
@@ -52,7 +66,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',
@@ -62,263 +76,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.mockReturnValue({
-                previousReleaseEntity: createEntryBasedReleaseEntity({
-                    entryId: 'entry-1',
-                    action: 'unpublish'
-                }),
-                previousEntryVersion: {
-                    sys: {
-                        fieldStatus: {
-                            '*': {
-                                'en-US': 'draft'
-                            }
-                        }
-                    }
-                }
-            });
-            const { result } = renderHook(()=>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.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.mockReturnValue({
+                    previousReleaseEntity: createEntryBasedReleaseEntity({
+                        entityId,
+                        action: 'unpublish',
+                        entityType
+                    })
+                });
+                const { result } = renderHook(()=>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 } = renderHook(()=>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.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.mockReturnValue({
+                    previousReleaseEntity: createEntryBasedReleaseEntity({
+                        entityId,
+                        action: 'publish',
+                        entityType
+                    })
+                });
+                const { result } = renderHook(()=>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 } = renderHook(()=>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.mockReturnValue({
-                previousReleaseEntity: undefined,
-                previousEntryVersion: undefined
-            });
-            const { result } = renderHook(()=>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.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.mockReturnValue({
+                    previousReleaseEntity: createEntryBasedReleaseEntity({
+                        action: 'unpublish',
+                        entityType,
+                        entityId
+                    })
+                });
+                const { result } = renderHook(()=>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 } = renderHook(()=>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.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.mockReturnValue({
+                    previousReleaseEntity: undefined
+                });
+                const { result } = renderHook(()=>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 } = renderHook(()=>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.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.mockReturnValue({
+                    previousReleaseEntity: createLocaleBasedReleaseEntity({
+                        entityId,
+                        verb: 'remove',
+                        entityType
+                    })
+                });
+                const { result } = renderHook(()=>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 } = renderHook(()=>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.mockReturnValue({
+                    previousReleaseEntity: createLocaleBasedReleaseEntity({
+                        entityId: 'entry-1',
+                        verb: 'add',
+                        entityType
+                    })
+                });
+                const { result } = renderHook(()=>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.mockReturnValue({
-                previousReleaseEntity: undefined,
-                previousEntryVersion: undefined
+            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({
+                        ...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 } = renderHook(()=>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.mockReturnValue({
+                    previousReleaseEntity: undefined
+                });
+                const { result } = renderHook(()=>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/esm/index.js

@@ -18,5 +18,5 @@ export * from './hooks/useLocalePublishStatus';
 export * from './LocalePublishingEntityStatusBadge';
 export * from './ReleaseEntityStatusBadge';
 export * from './utils/determineReleaseAction';
-export * from './utils/getEntryReleaseStatus';
+export * from './utils/getEntityReleaseStatus';
 export * from './utils/parseReleaseParameters';

package/dist/esm/utils/{getEntryReleaseStatus.js → getEntityReleaseStatus.js}

@@ -1,6 +1,6 @@
 import { determineReleaseAction } from './determineReleaseAction';
-export function getEntryReleaseStatus(entryId, locales, release) {
-    const { releaseAction, entityItem, addLocales, removeLocales } = determineReleaseAction(entryId, release);
+export function getEntityReleaseStatus(entityId, locales, release) {
+    const { releaseAction, entityItem, addLocales, removeLocales } = determineReleaseAction(entityId, release);
     if (releaseAction === 'not-in-release' || !entityItem) {
         return {
             releaseAction