@contentful/field-editor-shared 2.5.1 → 2.6.0

package/dist/cjs/ReleaseEntityStatusBadge/index.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 _export_star(require("./ReleaseEntityStatusPopover"), exports);
 _export_star(require("./ReleaseEntityStatusBadge"), exports);
-_export_star(require("./types"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/cjs/hooks/useActiveReleaseLocalesStatuses.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useActiveReleaseLocalesStatuses", {
+    enumerable: true,
+    get: function() {
+        return 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,
+            releaseVersionMap,
+            activeRelease,
+            releases
+        }).previousReleaseEntity, [
+        entryId,
+        releaseVersionMap,
+        activeRelease,
+        releases
+    ]);
+    const activeReleaseReleaseEntity = (0, _react.useMemo)(()=>activeRelease?.entities.items.find((entity)=>entity.entity.sys.id === entryId), [
+        activeRelease?.entities.items,
+        entryId
+    ]);
+    const getLocaleStatus = (0, _react.useCallback)((localeCode)=>{
+        if (!activeReleaseReleaseEntity) {
+            return 'Not in release';
+        }
+        return activeReleaseReleaseEntity?.action === 'publish' || activeReleaseReleaseEntity?.add?.fields['*'].includes(localeCode) ? 'published' : 'draft';
+    }, [
+        activeReleaseReleaseEntity
+    ]);
+    const releaseLocalesStatusMap = (0, _react.useMemo)(()=>{
+        return locales.reduce((acc, locale)=>{
+            acc.set(locale.code, {
+                variant: 'secondary',
+                status: 'remainsDraft',
+                label: 'Remains draft',
+                locale
+            });
+            if (!activeReleaseReleaseEntity) {
+                acc.set(locale.code, {
+                    variant: 'secondary',
+                    status: 'notInRelease',
+                    label: 'Not in release',
+                    locale
+                });
+                return acc;
+            }
+            if (getLocaleStatus(locale.code) === 'draft') {
+                if (currentEntryDraft?.sys.fieldStatus) {
+                    const previousStatus = currentEntryDraft.sys.fieldStatus['*'][locale.code];
+                    if (previousStatus === 'published' || previousStatus === 'changed') {
+                        acc.set(locale.code, {
+                            status: 'becomesDraft',
+                            variant: 'warning',
+                            label: 'Becomes draft',
+                            locale
+                        });
+                    } else {
+                        acc.set(locale.code, {
+                            status: 'remainsDraft',
+                            variant: 'secondary',
+                            label: 'Remains draft',
+                            locale
+                        });
+                    }
+                } else if (previousReleaseEntity) {
+                    if (previousReleaseEntity.action === 'publish' || previousReleaseEntity.add.fields['*'].includes(locale.code)) {
+                        acc.set(locale.code, {
+                            status: 'becomesDraft',
+                            variant: 'warning',
+                            label: 'Becomes draft',
+                            locale
+                        });
+                    } else {
+                        acc.set(locale.code, {
+                            status: 'remainsDraft',
+                            variant: 'secondary',
+                            label: 'Remains draft',
+                            locale
+                        });
+                    }
+                }
+            } else if (getLocaleStatus(locale.code) === 'published') {
+                acc.set(locale.code, {
+                    variant: 'positive',
+                    status: 'willPublish',
+                    label: 'Will publish',
+                    locale
+                });
+            }
+            return acc;
+        }, new Map());
+    }, [
+        locales,
+        activeReleaseReleaseEntity,
+        getLocaleStatus,
+        currentEntryDraft?.sys.fieldStatus,
+        previousReleaseEntity
+    ]);
+    return {
+        releaseLocalesStatusMap
+    };
+};

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

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _react = require("@testing-library/react");
+const _getPreviousReleaseEntryVersion = require("../utils/getPreviousReleaseEntryVersion");
+const _useActiveReleaseLocalesStatuses = require("./useActiveReleaseLocalesStatuses");
+const buildEntry = (status)=>({
+        sys: {
+            fieldStatus: {
+                '*': {
+                    'en-US': status
+                }
+            }
+        }
+    });
+const createEntryBasedReleaseEntity = ({ entryId = 'entry-1', action = 'publish' })=>({
+        entity: {
+            sys: {
+                type: 'Link',
+                linkType: 'Entry',
+                id: entryId
+            }
+        },
+        action
+    });
+const createEntryBasedRelease = ({ entryId, action } = {})=>({
+        title: 'Release 1',
+        sys: {
+            id: 'release-1',
+            type: 'Release',
+            schemaVersion: 'Release.v2'
+        },
+        entities: {
+            items: [
+                createEntryBasedReleaseEntity({
+                    entryId,
+                    action
+                })
+            ]
+        }
+    });
+const createLocaleBasedReleaseEntity = ({ entryId = 'entry-1', verb = 'add' })=>({
+        entity: {
+            sys: {
+                type: 'Link',
+                linkType: 'Entry',
+                id: entryId
+            }
+        },
+        [verb]: {
+            fields: {
+                '*': [
+                    'en-US'
+                ]
+            }
+        }
+    });
+const createLocaleBasedRelease = ({ entryId, verb } = {})=>({
+        title: 'Release 1',
+        sys: {
+            id: 'release-1',
+            type: 'Release',
+            schemaVersion: 'Release.v2'
+        },
+        entities: {
+            items: [
+                createLocaleBasedReleaseEntity({
+                    entryId,
+                    verb
+                })
+            ]
+        }
+    });
+jest.mock('../utils/getPreviousReleaseEntryVersion', ()=>({
+        getPreviousReleaseEntryVersion: jest.fn()
+    }));
+const baseParams = {
+    entryId: 'entry-1',
+    locales: [
+        {
+            code: 'en-US'
+        }
+    ],
+    isActiveReleaseLoading: false,
+    releaseVersionMap: new Map(),
+    releases: {
+        items: []
+    }
+};
+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: {
+                    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'
+                            }
+                        }
+                    }
+                }
+            });
+            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'
+                            }
+                        }
+                    }
+                }
+            });
+            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'
+                            }
+                        }
+                    }
+                }
+            });
+            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'
+                            }
+                        }
+                    }
+                }
+            });
+            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'
+                            }
+                        }
+                    }
+                }
+            });
+            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 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: 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'
+                }
+            });
+        });
+    });
+});

package/dist/cjs/index.js

@@ -111,8 +111,11 @@ const _PredefinedValuesError = require("./PredefinedValuesError");
 const _typesEntity = require("./typesEntity");
 const _isValidImage = require("./utils/isValidImage");
 const _shortenStorageUnit = require("./utils/shortenStorageUnit");
+_export_star(require("./utils/parseReleaseParameters"), exports);
 _export_star(require("./hooks/useLocalePublishStatus"), exports);
 _export_star(require("./hooks/useActiveLocales"), exports);
+_export_star(require("./types"), exports);
+_export_star(require("./hooks/useActiveReleaseLocalesStatuses"), exports);
 _export_star(require("./LocalePublishingEntityStatusBadge"), exports);
 _export_star(require("./ReleaseEntityStatusBadge"), exports);
 const _ModalDialogLauncher = /*#__PURE__*/ _interop_require_wildcard(require("./ModalDialogLauncher"));

package/dist/cjs/utils/getPreviousReleaseEntryVersion.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPreviousReleaseEntryVersion", {
+    enumerable: true,
+    get: function() {
+        return getPreviousReleaseEntryVersion;
+    }
+});
+const _datefns = require("date-fns");
+function getPreviousReleaseEntryVersion({ entryId, releaseVersionMap, activeRelease, releases }) {
+    const orderedScheduledReleases = releases?.items.filter((r)=>r.startDate).sort((a, b)=>(0, _datefns.compareAsc)(new Date(a.startDate), new Date(b.startDate)));
+    const indexOfActive = orderedScheduledReleases?.findIndex((r)=>r.sys.id === activeRelease?.sys.id);
+    let previousRelease;
+    let previousReleaseEntity;
+    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);
+            if (action !== 'not-in-release') {
+                previousRelease = release;
+                previousReleaseEntity = release.entities.items.find((e)=>e.entity.sys.id === entryId);
+                break;
+            }
+        }
+    }
+    return {
+        previousRelease,
+        previousReleaseEntity
+    };
+}

package/dist/cjs/utils/parseReleaseParameters.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseReleaseParams", {
+    enumerable: true,
+    get: function() {
+        return parseReleaseParams;
+    }
+});
+function parseReleaseParams(raw) {
+    let parsedRaw;
+    try {
+        parsedRaw = JSON.parse(raw);
+    } catch (e) {
+        throw new Error('Failed to parse release parameters: invalid JSON');
+    }
+    const releaseVersionMap = new Map();
+    for (const [entryId, innerObj] of Object.entries(parsedRaw.releaseVersionMap)){
+        const innerMap = new Map();
+        for (const [localeKey, actionData] of Object.entries(innerObj)){
+            innerMap.set(localeKey, actionData);
+        }
+        releaseVersionMap.set(entryId, innerMap);
+    }
+    return {
+        releaseVersionMap,
+        locales: parsedRaw.locales,
+        activeRelease: parsedRaw.activeRelease,
+        isActiveReleaseLoading: parsedRaw.isActiveReleaseLoading,
+        releases: parsedRaw.releases
+    };
+}

package/dist/esm/ReleaseEntityStatusBadge/index.js

@@ -1,3 +1,2 @@
 export * from './ReleaseEntityStatusPopover';
 export * from './ReleaseEntityStatusBadge';
-export * from './types';

package/dist/esm/hooks/useActiveReleaseLocalesStatuses.js

@@ -0,0 +1,99 @@
+import { useCallback, useMemo } from 'react';
+import { getPreviousReleaseEntryVersion } from '../utils/getPreviousReleaseEntryVersion';
+export const useActiveReleaseLocalesStatuses = ({ currentEntryDraft, entryId, releaseVersionMap, locales, activeRelease, releases })=>{
+    const previousReleaseEntity = useMemo(()=>getPreviousReleaseEntryVersion({
+            entryId,
+            releaseVersionMap,
+            activeRelease,
+            releases
+        }).previousReleaseEntity, [
+        entryId,
+        releaseVersionMap,
+        activeRelease,
+        releases
+    ]);
+    const activeReleaseReleaseEntity = useMemo(()=>activeRelease?.entities.items.find((entity)=>entity.entity.sys.id === entryId), [
+        activeRelease?.entities.items,
+        entryId
+    ]);
+    const getLocaleStatus = useCallback((localeCode)=>{
+        if (!activeReleaseReleaseEntity) {
+            return 'Not in release';
+        }
+        return activeReleaseReleaseEntity?.action === 'publish' || activeReleaseReleaseEntity?.add?.fields['*'].includes(localeCode) ? 'published' : 'draft';
+    }, [
+        activeReleaseReleaseEntity
+    ]);
+    const releaseLocalesStatusMap = useMemo(()=>{
+        return locales.reduce((acc, locale)=>{
+            acc.set(locale.code, {
+                variant: 'secondary',
+                status: 'remainsDraft',
+                label: 'Remains draft',
+                locale
+            });
+            if (!activeReleaseReleaseEntity) {
+                acc.set(locale.code, {
+                    variant: 'secondary',
+                    status: 'notInRelease',
+                    label: 'Not in release',
+                    locale
+                });
+                return acc;
+            }
+            if (getLocaleStatus(locale.code) === 'draft') {
+                if (currentEntryDraft?.sys.fieldStatus) {
+                    const previousStatus = currentEntryDraft.sys.fieldStatus['*'][locale.code];
+                    if (previousStatus === 'published' || previousStatus === 'changed') {
+                        acc.set(locale.code, {
+                            status: 'becomesDraft',
+                            variant: 'warning',
+                            label: 'Becomes draft',
+                            locale
+                        });
+                    } else {
+                        acc.set(locale.code, {
+                            status: 'remainsDraft',
+                            variant: 'secondary',
+                            label: 'Remains draft',
+                            locale
+                        });
+                    }
+                } else if (previousReleaseEntity) {
+                    if (previousReleaseEntity.action === 'publish' || previousReleaseEntity.add.fields['*'].includes(locale.code)) {
+                        acc.set(locale.code, {
+                            status: 'becomesDraft',
+                            variant: 'warning',
+                            label: 'Becomes draft',
+                            locale
+                        });
+                    } else {
+                        acc.set(locale.code, {
+                            status: 'remainsDraft',
+                            variant: 'secondary',
+                            label: 'Remains draft',
+                            locale
+                        });
+                    }
+                }
+            } else if (getLocaleStatus(locale.code) === 'published') {
+                acc.set(locale.code, {
+                    variant: 'positive',
+                    status: 'willPublish',
+                    label: 'Will publish',
+                    locale
+                });
+            }
+            return acc;
+        }, new Map());
+    }, [
+        locales,
+        activeReleaseReleaseEntity,
+        getLocaleStatus,
+        currentEntryDraft?.sys.fieldStatus,
+        previousReleaseEntity
+    ]);
+    return {
+        releaseLocalesStatusMap
+    };
+};

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

@@ -0,0 +1,325 @@
+import { renderHook } from '@testing-library/react';
+import { getPreviousReleaseEntryVersion } from '../utils/getPreviousReleaseEntryVersion';
+import { useActiveReleaseLocalesStatuses } from './useActiveReleaseLocalesStatuses';
+const buildEntry = (status)=>({
+        sys: {
+            fieldStatus: {
+                '*': {
+                    'en-US': status
+                }
+            }
+        }
+    });
+const createEntryBasedReleaseEntity = ({ entryId = 'entry-1', action = 'publish' })=>({
+        entity: {
+            sys: {
+                type: 'Link',
+                linkType: 'Entry',
+                id: entryId
+            }
+        },
+        action
+    });
+const createEntryBasedRelease = ({ entryId, action } = {})=>({
+        title: 'Release 1',
+        sys: {
+            id: 'release-1',
+            type: 'Release',
+            schemaVersion: 'Release.v2'
+        },
+        entities: {
+            items: [
+                createEntryBasedReleaseEntity({
+                    entryId,
+                    action
+                })
+            ]
+        }
+    });
+const createLocaleBasedReleaseEntity = ({ entryId = 'entry-1', verb = 'add' })=>({
+        entity: {
+            sys: {
+                type: 'Link',
+                linkType: 'Entry',
+                id: entryId
+            }
+        },
+        [verb]: {
+            fields: {
+                '*': [
+                    'en-US'
+                ]
+            }
+        }
+    });
+const createLocaleBasedRelease = ({ entryId, verb } = {})=>({
+        title: 'Release 1',
+        sys: {
+            id: 'release-1',
+            type: 'Release',
+            schemaVersion: 'Release.v2'
+        },
+        entities: {
+            items: [
+                createLocaleBasedReleaseEntity({
+                    entryId,
+                    verb
+                })
+            ]
+        }
+    });
+jest.mock('../utils/getPreviousReleaseEntryVersion', ()=>({
+        getPreviousReleaseEntryVersion: jest.fn()
+    }));
+const baseParams = {
+    entryId: 'entry-1',
+    locales: [
+        {
+            code: 'en-US'
+        }
+    ],
+    isActiveReleaseLoading: false,
+    releaseVersionMap: new Map(),
+    releases: {
+        items: []
+    }
+};
+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: {
+                    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'
+                            }
+                        }
+                    }
+                }
+            });
+            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'
+                            }
+                        }
+                    }
+                }
+            });
+            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'
+                            }
+                        }
+                    }
+                }
+            });
+            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'
+                            }
+                        }
+                    }
+                }
+            });
+            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'
+                            }
+                        }
+                    }
+                }
+            });
+            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 Not in release status when entry is not in the release', ()=>{
+            getPreviousReleaseEntryVersion.mockReturnValue({
+                previousReleaseEntity: undefined,
+                previousEntryVersion: undefined
+            });
+            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'
+                }
+            });
+        });
+    });
+});

package/dist/esm/index.js

@@ -6,11 +6,14 @@ export { PredefinedValuesError } from './PredefinedValuesError';
 export { Asset, Entry, File } from './typesEntity';
 export { isValidImage } from './utils/isValidImage';
 export { shortenStorageUnit, toLocaleString } from './utils/shortenStorageUnit';
+export * from './utils/parseReleaseParameters';
 export * from './hooks/useLocalePublishStatus';
 export * from './hooks/useActiveLocales';
 export { ModalDialogLauncher };
 export { entityHelpers };
 export { ConstraintsUtils };
+export * from './types';
+export * from './hooks/useActiveReleaseLocalesStatuses';
 export * from './LocalePublishingEntityStatusBadge';
 export * from './ReleaseEntityStatusBadge';
 import * as ModalDialogLauncher from './ModalDialogLauncher';

package/dist/esm/utils/getPreviousReleaseEntryVersion.js

@@ -0,0 +1,22 @@
+import { compareAsc } from 'date-fns';
+export function getPreviousReleaseEntryVersion({ entryId, 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;
+    let previousReleaseEntity;
+    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);
+            if (action !== 'not-in-release') {
+                previousRelease = release;
+                previousReleaseEntity = release.entities.items.find((e)=>e.entity.sys.id === entryId);
+                break;
+            }
+        }
+    }
+    return {
+        previousRelease,
+        previousReleaseEntity
+    };
+}

package/dist/esm/utils/parseReleaseParameters.js

@@ -0,0 +1,23 @@
+export function parseReleaseParams(raw) {
+    let parsedRaw;
+    try {
+        parsedRaw = JSON.parse(raw);
+    } catch (e) {
+        throw new Error('Failed to parse release parameters: invalid JSON');
+    }
+    const releaseVersionMap = new Map();
+    for (const [entryId, innerObj] of Object.entries(parsedRaw.releaseVersionMap)){
+        const innerMap = new Map();
+        for (const [localeKey, actionData] of Object.entries(innerObj)){
+            innerMap.set(localeKey, actionData);
+        }
+        releaseVersionMap.set(entryId, innerMap);
+    }
+    return {
+        releaseVersionMap,
+        locales: parsedRaw.locales,
+        activeRelease: parsedRaw.activeRelease,
+        isActiveReleaseLoading: parsedRaw.isActiveReleaseLoading,
+        releases: parsedRaw.releases
+    };
+}

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { ReleaseAction } from './types';
+import type { ReleaseAction } from '../types';
 type ReleaseEntityActionBadgeProps = {
     action: ReleaseAction;
     className?: string;

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

@@ -1,6 +1,6 @@
 import React from 'react';
 import type { LocaleProps } from 'contentful-management';
-import { ReleaseLocalesStatusMap } from './types';
+import { ReleaseLocalesStatusMap } from '../types';
 type ReleaseEntityStatusLocalesListProps = {
     statusMap: ReleaseLocalesStatusMap;
     activeLocales?: Pick<LocaleProps, 'code'>[];

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

@@ -1,6 +1,6 @@
 import React from 'react';
 import type { LocaleProps } from 'contentful-management';
-import type { ReleaseLocalesStatusMap } from './types';
+import type { ReleaseLocalesStatusMap } from '../types';
 type ReleaseLocalePublishingPopoverProps = {
     releaseLocalesStatusMap: ReleaseLocalesStatusMap;
     activeLocales: Pick<LocaleProps, 'code'>[];

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

@@ -1,3 +1,2 @@
 export * from './ReleaseEntityStatusPopover';
 export * from './ReleaseEntityStatusBadge';
-export * from './types';

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

@@ -0,0 +1,13 @@
+import type { ReleaseAction, ReleaseLocalesStatusMap } from '@contentful/field-editor-shared';
+import type { 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;
+    releaseVersionMap: Map<string, Map<string, ReleaseAction>>;
+    locales: LocaleProps[];
+    activeRelease: ReleaseV2Props;
+    releases: CollectionProp<ReleaseV2Props>;
+}) => {
+    releaseLocalesStatusMap: ReleaseLocalesStatusMap;
+};

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

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -7,11 +7,14 @@ export { PredefinedValuesError } from './PredefinedValuesError';
 export { Asset, Entry, File } from './typesEntity';
 export { isValidImage } from './utils/isValidImage';
 export { shortenStorageUnit, toLocaleString } from './utils/shortenStorageUnit';
+export * from './utils/parseReleaseParameters';
 export * from './hooks/useLocalePublishStatus';
 export * from './hooks/useActiveLocales';
 export { ModalDialogLauncher };
 export { entityHelpers };
 export { ConstraintsUtils };
+export * from './types';
+export * from './hooks/useActiveReleaseLocalesStatuses';
 export * from './LocalePublishingEntityStatusBadge';
 export * from './ReleaseEntityStatusBadge';
 import * as ModalDialogLauncher from './ModalDialogLauncher';

package/dist/types/types.d.ts

@@ -1,3 +1,6 @@
+import type { BadgeVariant } from '@contentful/f36-components';
+import type { CollectionProp, ReleaseProps } from 'contentful-management/types';
+import type { LocaleProps } from 'contentful-management/types';
 export type ValidationType = {
     type: 'max';
     max: number;
@@ -9,3 +12,48 @@ export type ValidationType = {
     min: number;
     max: number;
 };
+export type ReleaseV2Entity = {
+    entity: {
+        sys: {
+            type: 'Link';
+            linkType: 'Entry';
+            id: string;
+        };
+    };
+    action: 'publish' | 'unpublish';
+};
+export type ReleaseV2EntityWithLocales = {
+    entity: {
+        sys: {
+            type: 'Link';
+            linkType: 'Entry';
+            id: string;
+        };
+    };
+    add: {
+        fields: {
+            '*': string[];
+        };
+    };
+    remove: {
+        fields: {
+            '*': string[];
+        };
+    };
+};
+export type ReleaseV2Props = Omit<ReleaseProps, 'entities' | 'sys'> & {
+    sys: ReleaseProps['sys'] & {
+        schemaVersion: 'Release.v2';
+    };
+    entities: CollectionProp<ReleaseV2Entity | ReleaseV2EntityWithLocales>;
+    startDate?: string;
+};
+export type ReleaseAction = 'publish' | 'unpublish' | 'not-in-release';
+export type ReleaseEntityStatus = 'willPublish' | 'becomesDraft' | 'remainsDraft' | 'notInRelease';
+export type ReleaseLocalesStatus = {
+    status: ReleaseEntityStatus;
+    variant: BadgeVariant;
+    label: string;
+    locale: LocaleProps;
+};
+export type ReleaseLocalesStatusMap = Map<string, ReleaseLocalesStatus>;

package/dist/types/utils/getPreviousReleaseEntryVersion.d.ts

@@ -0,0 +1,11 @@
+import type { CollectionProp } from 'contentful-management/types';
+import type { ReleaseAction, ReleaseV2Entity, ReleaseV2EntityWithLocales, ReleaseV2Props } from '../types';
+export declare function getPreviousReleaseEntryVersion({ entryId, releaseVersionMap, activeRelease, releases, }: {
+    entryId: string;
+    releaseVersionMap: Map<string, Map<string, ReleaseAction>>;
+    activeRelease: ReleaseV2Props | undefined;
+    releases: CollectionProp<ReleaseV2Props> | undefined;
+}): {
+    previousReleaseEntity: ReleaseV2Entity | ReleaseV2EntityWithLocales | undefined;
+    previousRelease: ReleaseV2Props | undefined;
+};

package/dist/types/utils/parseReleaseParameters.d.ts

@@ -0,0 +1,11 @@
+import type { ReleaseV2Props } from '@contentful/field-editor-shared';
+import type { CollectionProp, LocaleProps } from 'contentful-management';
+import type { ReleaseAction } from '../types';
+export type ParsedReleaseParams = {
+    releaseVersionMap: Map<string, Map<string, ReleaseAction>>;
+    locales: LocaleProps[];
+    activeRelease: ReleaseV2Props;
+    isActiveReleaseLoading: boolean;
+    releases: CollectionProp<ReleaseV2Props>;
+};
+export declare function parseReleaseParams(raw: string): ParsedReleaseParams;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/field-editor-shared",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",
@@ -55,5 +55,5 @@
   "publishConfig": {
     "registry": "https://npm.pkg.github.com/"
   },
-  "gitHead": "5228c3bb1871807c1832459f03d17477e8beb75b"
+  "gitHead": "07bbbf610db4000897fa8e6f38e3ab6ace7e02cf"
 }

package/dist/cjs/ReleaseEntityStatusBadge/types.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/dist/esm/ReleaseEntityStatusBadge/types.js

@@ -1 +0,0 @@
-export { };

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

@@ -1,11 +0,0 @@
-import { BadgeVariant } from '@contentful/f36-components';
-import { LocaleProps } from 'contentful-management/types';
-export type ReleaseAction = 'publish' | 'unpublish' | 'not-in-release';
-export type ReleaseEntityStatus = 'willPublish' | 'becomesDraft' | 'remainsDraft' | 'notInRelease';
-export type ReleaseLocalesStatus = {
-    status: ReleaseEntityStatus;
-    variant: BadgeVariant;
-    label: string;
-    locale: LocaleProps;
-};
-export type ReleaseLocalesStatusMap = Map<string, ReleaseLocalesStatus>;