@contentful/field-editor-shared 2.11.2 → 2.12.1

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

package/dist/esm/utils/{getPreviousReleaseEntryVersion.js → getPreviousReleaseEntity.js}

@@ -1,5 +1,5 @@
 import { compareAsc } from 'date-fns';
-export function getPreviousReleaseEntryVersion({ entryId, releaseVersionMap, activeRelease, releases }) {
+export function getPreviousReleaseEntity({ entityId, entityType, releaseVersionMap, activeRelease, releases }) {
     const orderedScheduledReleases = releases?.items.filter((r)=>r.startDate).sort((a, b)=>compareAsc(new Date(a.startDate), new Date(b.startDate)));
     const indexOfActive = orderedScheduledReleases?.findIndex((r)=>r.sys.id === activeRelease?.sys.id);
     let previousRelease;
@@ -7,10 +7,10 @@ export function getPreviousReleaseEntryVersion({ entryId, releaseVersionMap, act
     if (indexOfActive && indexOfActive > 0) {
         for(let i = indexOfActive - 1; i >= 0; i--){
             const release = orderedScheduledReleases[i];
-            const action = releaseVersionMap.get(entryId)?.get(release.sys.id);
+            const action = releaseVersionMap.get(entityId)?.get(release.sys.id);
             if (action !== 'not-in-release') {
                 previousRelease = release;
-                previousReleaseEntity = release.entities.items.find((e)=>e.entity.sys.id === entryId);
+                previousReleaseEntity = release.entities.items.find((e)=>e.entity.sys.id === entityId && e.entity.sys.linkType === entityType);
                 break;
             }
         }

package/dist/types/LocalePublishingEntityStatusBadge/LocalePublishingPopover.d.ts

@@ -8,5 +8,5 @@ type LocalePublishingPopoverProps = {
     activeLocales?: Pick<LocaleProps, 'code'>[];
     localesStatusMap?: LocalePublishStatusMap;
 };
-export declare function LocalePublishingPopover({ entity, jobs, isScheduled, localesStatusMap, activeLocales }: LocalePublishingPopoverProps): React.JSX.Element;
+export declare function LocalePublishingPopover({ entity, jobs, isScheduled, localesStatusMap, activeLocales, }: LocalePublishingPopoverProps): React.JSX.Element;
 export {};

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

@@ -1,9 +1,10 @@
 import type { ReleaseAction, ReleaseLocalesStatusMap } from '@contentful/field-editor-shared';
-import type { CollectionProp, EntryProps, LocaleProps } from 'contentful-management/types';
+import type { AssetProps, CollectionProp, EntryProps, LocaleProps } from 'contentful-management/types';
 import type { ReleaseV2Props } from '../types';
-export declare const useActiveReleaseLocalesStatuses: ({ currentEntryDraft, entryId, releaseVersionMap, locales, activeRelease, releases, }: {
-    currentEntryDraft: EntryProps;
-    entryId: string;
+export declare const useActiveReleaseLocalesStatuses: ({ currentEntityDraft, entityId, entityType, releaseVersionMap, locales, activeRelease, releases, }: {
+    currentEntityDraft: EntryProps | AssetProps;
+    entityId: string;
+    entityType: 'Entry' | 'Asset';
     releaseVersionMap: Map<string, Map<string, ReleaseAction>>;
     locales: LocaleProps[];
     activeRelease: ReleaseV2Props | undefined;

package/dist/types/index.d.ts

@@ -20,5 +20,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/types/types.d.ts

@@ -16,7 +16,7 @@ export type ReleaseV2Entity = {
     entity: {
         sys: {
             type: 'Link';
-            linkType: 'Entry';
+            linkType: 'Entry' | 'Asset';
             id: string;
         };
     };
@@ -26,7 +26,7 @@ export type ReleaseV2EntityWithLocales = {
     entity: {
         sys: {
             type: 'Link';
-            linkType: 'Entry';
+            linkType: 'Entry' | 'Asset';
             id: string;
         };
     };