@contentful/field-editor-shared 2.11.1 → 2.12.0

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

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

package/dist/cjs/index.js

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

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

@@ -2,15 +2,15 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "getEntryReleaseStatus", {
+Object.defineProperty(exports, "getEntityReleaseStatus", {
     enumerable: true,
     get: function() {
-        return getEntryReleaseStatus;
+        return getEntityReleaseStatus;
     }
 });
 const _determineReleaseAction = require("./determineReleaseAction");
-function getEntryReleaseStatus(entryId, locales, release) {
-    const { releaseAction, entityItem, addLocales, removeLocales } = (0, _determineReleaseAction.determineReleaseAction)(entryId, release);
+function getEntityReleaseStatus(entityId, locales, release) {
+    const { releaseAction, entityItem, addLocales, removeLocales } = (0, _determineReleaseAction.determineReleaseAction)(entityId, release);
     if (releaseAction === 'not-in-release' || !entityItem) {
         return {
             releaseAction

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

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "getPreviousReleaseEntryVersion", {
+Object.defineProperty(exports, "getPreviousReleaseEntity", {
     enumerable: true,
     get: function() {
-        return getPreviousReleaseEntryVersion;
+        return getPreviousReleaseEntity;
     }
 });
 const _datefns = require("date-fns");
-function getPreviousReleaseEntryVersion({ entryId, releaseVersionMap, activeRelease, releases }) {
+function getPreviousReleaseEntity({ entityId, entityType, 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;
@@ -17,10 +17,10 @@ function getPreviousReleaseEntryVersion({ entryId, releaseVersionMap, activeRele
     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/esm/LocalePublishingEntityStatusBadge/LocalePublishingPopover.js

@@ -1,5 +1,6 @@
 import React, { useCallback, useRef, useState } from 'react';
-import { EntityStatusBadge, Flex, Popover, generateIcon } from '@contentful/f36-components';
+import { EntityStatusBadge, Flex, Popover } from '@contentful/f36-components';
+import { ArrowDownIcon } from '@contentful/f36-icons';
 import tokens from '@contentful/f36-tokens';
 import { cx, css } from 'emotion';
 import * as entityHelpers from '../utils/entityHelpers';
@@ -93,14 +94,6 @@ const styles = {
         padding: `${tokens.spacing2Xs} 0`
     })
 };
-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"
-    })
-});
 const determineBadgeStatus = (localesStatusMap, activeLocales)=>{
     if (!localesStatusMap) return;
     if (localesStatusMap.size === 1 || activeLocales && activeLocales.length === 1) return {