@contentful/field-editor-reference 5.21.2 → 5.21.4

package/dist/esm/components/ResourceEntityErrorCard/ResourceEntityErrorCard.js

@@ -4,12 +4,12 @@ import { MissingEntityCard } from '../MissingEntityCard/MissingEntityCard';
 import { UnsupportedEntityCard } from './UnsupportedEntityCard';
 export function ResourceEntityErrorCard(props) {
     if (isUnsupportedError(props.error)) {
-        return /*#__PURE__*/ React.createElement(UnsupportedEntityCard, {
+        return React.createElement(UnsupportedEntityCard, {
             linkType: props.linkType,
             isSelected: props.isSelected
         });
     }
-    return /*#__PURE__*/ React.createElement(MissingEntityCard, {
+    return React.createElement(MissingEntityCard, {
         entityType: "Entry",
         isDisabled: props.isDisabled,
         isSelected: props.isSelected,

package/dist/esm/components/ResourceEntityErrorCard/UnsupportedEntityCard.js

@@ -7,10 +7,10 @@ const styles = {
     })
 };
 export function UnsupportedEntityCard(props) {
-    return /*#__PURE__*/ React.createElement(Card, {
+    return React.createElement(Card, {
         className: styles.card,
         isSelected: props.isSelected
-    }, /*#__PURE__*/ React.createElement(SectionHeading, {
+    }, React.createElement(SectionHeading, {
         marginBottom: "none"
     }, "Resource type ", props.linkType, " is currently not supported"));
 }

package/dist/esm/components/ScheduledIconWithTooltip/ScheduleTooltip.js

@@ -1,12 +1,12 @@
 import * as React from 'react';
 import { Tooltip } from '@contentful/f36-components';
 import { formatDateAndTime } from './formatDateAndTime';
-export const getScheduleTooltipContent = ({ job, jobsCount })=>{
+export const getScheduleTooltipContent = ({ job , jobsCount  })=>{
     return `Will ${job.action.toLowerCase()} ${formatDateAndTime(job.scheduledFor.datetime).toLowerCase()}
   ${jobsCount > 1 ? `+ ${jobsCount - 1} more` : ''}`;
 };
-export const ScheduleTooltip = ({ job, jobsCount, children })=>{
-    return /*#__PURE__*/ React.createElement(Tooltip, {
+export const ScheduleTooltip = ({ job , jobsCount , children  })=>{
+    return React.createElement(Tooltip, {
         placement: "top",
         testId: job.sys.id,
         as: "div",

package/dist/esm/components/ScheduledIconWithTooltip/ScheduledIconWithTooltip.js

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { ScheduleTooltip } from './ScheduleTooltip';
-export const ScheduledIconWithTooltip = ({ entityType, entityId, getEntityScheduledActions, children })=>{
+export const ScheduledIconWithTooltip = ({ entityType , entityId , getEntityScheduledActions , children  })=>{
     const [status, setStatus] = React.useState({
         type: 'loading'
     });
@@ -16,9 +16,6 @@ export const ScheduledIconWithTooltip = ({ entityType, entityId, getEntitySchedu
                 error: e
             });
         });
-    // This should only be ever called once. Following the eslint hint to add used
-    // dependencies will cause page freeze (infinite loop)
-    // eslint-disable-next-line -- TODO: describe this disable
     }, []);
     if (status.type === 'loading' || status.type === 'error') {
         return null;
@@ -28,7 +25,7 @@ export const ScheduledIconWithTooltip = ({ entityType, entityId, getEntitySchedu
         return null;
     }
     const mostRelevantJob = jobs[0];
-    return /*#__PURE__*/ React.createElement(ScheduleTooltip, {
+    return React.createElement(ScheduleTooltip, {
         job: mostRelevantJob,
         jobsCount: jobs.length
     }, children);

package/dist/esm/components/ScheduledIconWithTooltip/formatDateAndTime.js

@@ -1,9 +1,5 @@
-// eslint-disable-next-line -- TODO: describe this disable  no-restricted-imports
 import moment from 'moment';
-/**
- * @param {Date|string} date A valid constructor argument for moment()
- * @param {boolean=} short Render only Today/Tomorrow/Yesterday if valid. Defaults to false
- */ export const formatDate = (date, short)=>{
+export const formatDate = (date, short)=>{
     switch(moment().startOf('day').diff(moment(date).startOf('day'), 'days')){
         case 0:
             return short ? 'Today' : `Today, ${moment(date).format('DD MMM YYYY')}`;
@@ -15,12 +11,7 @@ import moment from 'moment';
             return moment(date).format('ddd, DD MMM YYYY');
     }
 };
-/**
- * Returns the time portion of a date in the local time in the format H:MM AM/PM
- *
- * == Examples
- * * `T15:36:45.000Z` => 3:36 PM (if in +0:00 offset)
- */ export const formatTime = (date)=>{
+export const formatTime = (date)=>{
     return moment.utc(date).local().format('h:mm A');
 };
 export const formatDateAndTime = (date, short)=>{

package/dist/esm/components/SpaceName/SpaceName.js

@@ -21,18 +21,18 @@ const styles = {
 export function SpaceName(props) {
     let content = `Space: ${props.spaceName}`;
     if (props.environmentName) content += ` (Env.: ${props.environmentName})`;
-    return /*#__PURE__*/ React.createElement(Tooltip, {
+    return React.createElement(Tooltip, {
         placement: "top",
         as: "div",
         content: content
-    }, /*#__PURE__*/ React.createElement(Flex, {
+    }, React.createElement(Flex, {
         alignItems: "center",
         gap: "spacingXs"
-    }, /*#__PURE__*/ React.createElement(FolderOpenTrimmedIcon, {
+    }, React.createElement(FolderOpenTrimmedIcon, {
         className: styles.spaceIcon,
         size: "tiny",
         "aria-label": "Source space"
-    }), /*#__PURE__*/ React.createElement(Text, {
+    }), React.createElement(Text, {
         className: styles.spaceName
     }, props.spaceName)));
 }

package/dist/esm/entries/MultipleEntryReferenceEditor.js

@@ -5,20 +5,20 @@ import { SortableLinkList } from '../common/SortableLinkList';
 import { FetchingWrappedEntryCard } from './WrappedEntryCard/FetchingWrappedEntryCard';
 export function MultipleEntryReferenceEditor(props) {
     const [indexToUpdate, setIndexToUpdate] = React.useState(undefined);
-    const updateBeforeSortStart = ({ index })=>{
+    const updateBeforeSortStart = ({ index  })=>{
         setIndexToUpdate(index);
     };
-    return /*#__PURE__*/ React.createElement(MultipleReferenceEditor, {
+    return React.createElement(MultipleReferenceEditor, {
         ...props,
         entityType: "Entry",
         setIndexToUpdate: setIndexToUpdate
-    }, (childrenProps)=>/*#__PURE__*/ React.createElement(SortableLinkList, {
+    }, (childrenProps)=>React.createElement(SortableLinkList, {
             ...childrenProps,
             sortingStrategy: verticalListSortingStrategy,
             updateBeforeSortStart: updateBeforeSortStart
-        }, ({ items, item, index, isDisabled, DragHandle })=>{
+        }, ({ items , item , index , isDisabled , DragHandle  })=>{
             const lastIndex = items.length - 1;
-            return /*#__PURE__*/ React.createElement(FetchingWrappedEntryCard, {
+            return React.createElement(FetchingWrappedEntryCard, {
                 ...childrenProps,
                 key: `${item.sys.id}-${index}`,
                 index: index,

package/dist/esm/entries/SingleEntryReferenceEditor.js

@@ -2,11 +2,11 @@ import * as React from 'react';
 import { SingleReferenceEditor } from '../common/SingleReferenceEditor';
 import { FetchingWrappedEntryCard } from './WrappedEntryCard/FetchingWrappedEntryCard';
 export function SingleEntryReferenceEditor(props) {
-    return /*#__PURE__*/ React.createElement(SingleReferenceEditor, {
+    return React.createElement(SingleReferenceEditor, {
         ...props,
         entityType: "Entry"
-    }, ({ allContentTypes, isDisabled, entityId, setValue, renderCustomCard, hasCardRemoveActions, hasCardEditActions })=>{
-        return /*#__PURE__*/ React.createElement(FetchingWrappedEntryCard, {
+    }, ({ allContentTypes , isDisabled , entityId , setValue , renderCustomCard , hasCardRemoveActions , hasCardEditActions  })=>{
+        return React.createElement(FetchingWrappedEntryCard, {
             ...props,
             allContentTypes: allContentTypes,
             isDisabled: isDisabled,

package/dist/esm/entries/WrappedEntryCard/FetchingWrappedEntryCard.js

@@ -15,10 +15,7 @@ async function openEntry(sdk, entryId, options) {
             });
             slide = result.slide;
             return slide;
-        } catch (e) {
-        // we don't allow to open multiple bulk editors for performance reasons
-        // proceed with a default openEntry
-        }
+        } catch (e) {}
     }
     const result = await sdk.navigator.openEntry(entryId, {
         slideIn: true
@@ -27,14 +24,14 @@ async function openEntry(sdk, entryId, options) {
     return slide;
 }
 export function FetchingWrappedEntryCard(props) {
-    const { data: entry, status } = useEntity('Entry', props.entryId);
-    const { getEntityScheduledActions } = useEntityLoader();
+    const { data: entry , status  } = useEntity('Entry', props.entryId);
+    const { getEntityScheduledActions  } = useEntityLoader();
     const loadEntityScheduledActions = React.useCallback(()=>getEntityScheduledActions('Entry', props.entryId), [
         getEntityScheduledActions,
         props.entryId
     ]);
     const size = props.viewType === 'link' ? 'small' : 'default';
-    const { getEntity } = useEntityLoader();
+    const { getEntity  } = useEntityLoader();
     const getAsset = (assetId)=>getEntity('Asset', assetId);
     const onEdit = async ()=>{
         const slide = await openEntry(props.sdk, props.entryId, {
@@ -65,13 +62,12 @@ export function FetchingWrappedEntryCard(props) {
                 entity: 'Entry'
             });
         }
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- TODO: Evaluate the dependencies
     }, [
         entry
     ]);
     return React.useMemo(()=>{
         if (status === 'error') {
-            const card = /*#__PURE__*/ React.createElement(MissingEntityCard, {
+            const card = React.createElement(MissingEntityCard, {
                 entityType: "Entry",
                 isDisabled: props.isDisabled,
                 onRemove: onRemoveEntry
@@ -88,7 +84,7 @@ export function FetchingWrappedEntryCard(props) {
             return card;
         }
         if (status === 'loading') {
-            return /*#__PURE__*/ React.createElement(EntryCard, {
+            return React.createElement(EntryCard, {
                 size: size,
                 isLoading: true
             });
@@ -109,7 +105,7 @@ export function FetchingWrappedEntryCard(props) {
             onMoveBottom: props.onMoveBottom,
             isBeingDragged: props.isBeingDragged
         };
-        const { hasCardEditActions, hasCardMoveActions, hasCardRemoveActions } = props;
+        const { hasCardEditActions , hasCardMoveActions , hasCardRemoveActions  } = props;
         function renderDefaultCard(props) {
             const builtinCardProps = {
                 ...sharedCardProps,
@@ -122,18 +118,15 @@ export function FetchingWrappedEntryCard(props) {
                 entry: (props?.entity) || sharedCardProps.entity,
                 entryUrl: props?.entityUrl || sharedCardProps.entityUrl
             };
-            return /*#__PURE__*/ React.createElement(WrappedEntryCard, builtinCardProps);
+            return React.createElement(WrappedEntryCard, builtinCardProps);
         }
         if (props.renderCustomCard) {
-            // LinkActionsProps are injected higher SingleReferenceEditor/MultipleReferenceEditor
             const renderedCustomCard = props.renderCustomCard(sharedCardProps, {}, renderDefaultCard);
-            // Only `false` indicates to render the original card. E.g. `null` would result in no card.
             if (renderedCustomCard !== false) {
                 return renderedCustomCard;
             }
         }
         return renderDefaultCard();
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- TODO: Evaluate the dependencies
     }, [
         props,
         status,

package/dist/esm/entries/WrappedEntryCard/WrappedEntryCard.js

@@ -6,7 +6,7 @@ import { entityHelpers, isValidImage } from '@contentful/field-editor-shared';
 import { css } from 'emotion';
 import { AssetThumbnail, MissingEntityCard, ScheduledIconWithTooltip } from '../../components';
 import { SpaceName } from '../../components/SpaceName/SpaceName';
-const { getEntryTitle, getEntityDescription, getEntryStatus, getEntryImage } = entityHelpers;
+const { getEntryTitle , getEntityDescription , getEntryStatus , getEntryImage  } = entityHelpers;
 const styles = {
     scheduleIcon: css({
         marginRight: tokens.spacing2Xs
@@ -20,7 +20,7 @@ const defaultProps = {
 };
 export function WrappedEntryCard(props) {
     const [file, setFile] = React.useState(null);
-    const { contentType } = props;
+    const { contentType  } = props;
     React.useEffect(()=>{
         if (props.entry) {
             getEntryImage({
@@ -43,7 +43,7 @@ export function WrappedEntryCard(props) {
     ]);
     const status = getEntryStatus(props.entry?.sys);
     if (status === 'deleted') {
-        return /*#__PURE__*/ React.createElement(MissingEntityCard, {
+        return React.createElement(MissingEntityCard, {
             entityType: "Entry",
             isDisabled: props.isDisabled,
             onRemove: props.onRemove
@@ -62,7 +62,7 @@ export function WrappedEntryCard(props) {
         localeCode: props.localeCode,
         defaultLocaleCode: props.defaultLocaleCode
     });
-    return /*#__PURE__*/ React.createElement(EntryCard, {
+    return React.createElement(EntryCard, {
         as: props.entryUrl ? 'a' : 'article',
         href: props.entryUrl,
         title: title,
@@ -71,58 +71,54 @@ export function WrappedEntryCard(props) {
         size: props.size,
         isSelected: props.isSelected,
         status: status,
-        icon: props.spaceName ? /*#__PURE__*/ React.createElement(SpaceName, {
+        icon: props.spaceName ? React.createElement(SpaceName, {
             spaceName: props.spaceName,
             environmentName: props.entry.sys.environment.sys.id
-        }) : /*#__PURE__*/ React.createElement(ScheduledIconWithTooltip, {
+        }) : React.createElement(ScheduledIconWithTooltip, {
             getEntityScheduledActions: props.getEntityScheduledActions,
             entityType: "Entry",
             entityId: props.entry.sys.id
-        }, /*#__PURE__*/ React.createElement(ClockIcon, {
+        }, React.createElement(ClockIcon, {
             className: styles.scheduleIcon,
             size: "small",
             variant: "muted",
             testId: "schedule-icon"
         })),
-        thumbnailElement: file && isValidImage(file) ? /*#__PURE__*/ React.createElement(AssetThumbnail, {
+        thumbnailElement: file && isValidImage(file) ? React.createElement(AssetThumbnail, {
             file: file
         }) : undefined,
         dragHandleRender: props.renderDragHandle,
         withDragHandle: !!props.renderDragHandle,
         actions: props.onEdit || props.onRemove ? [
-            props.hasCardEditActions && props.onEdit ? /*#__PURE__*/ React.createElement(MenuItem, {
+            props.hasCardEditActions && props.onEdit ? React.createElement(MenuItem, {
                 key: "edit",
                 testId: "edit",
                 onClick: ()=>{
                     props.onEdit && props.onEdit();
                 }
             }, "Edit") : null,
-            props.hasCardRemoveActions && props.onRemove ? /*#__PURE__*/ React.createElement(MenuItem, {
+            props.hasCardRemoveActions && props.onRemove ? React.createElement(MenuItem, {
                 key: "delete",
                 testId: "delete",
                 onClick: ()=>{
                     props.onRemove && props.onRemove();
                 }
             }, "Remove") : null,
-            props.hasCardMoveActions && (props.onMoveTop || props.onMoveBottom) ? /*#__PURE__*/ React.createElement(MenuDivider, {
+            props.hasCardMoveActions && (props.onMoveTop || props.onMoveBottom) ? React.createElement(MenuDivider, {
                 key: "divider"
             }) : null,
-            props.hasCardMoveActions && props.onMoveTop ? /*#__PURE__*/ React.createElement(MenuItem, {
+            props.hasCardMoveActions && props.onMoveTop ? React.createElement(MenuItem, {
                 key: "move-top",
                 onClick: ()=>props.onMoveTop && props.onMoveTop(),
                 testId: "move-top"
             }, "Move to top") : null,
-            props.hasCardMoveActions && props.onMoveBottom ? /*#__PURE__*/ React.createElement(MenuItem, {
+            props.hasCardMoveActions && props.onMoveBottom ? React.createElement(MenuItem, {
                 key: "move-bottom",
                 onClick: ()=>props.onMoveBottom && props.onMoveBottom(),
                 testId: "move-bottom"
             }, "Move to bottom") : null
         ].filter((item)=>item) : [],
-        onClick: // Providing an onClick handler messes up with some rich text
-        // features e.g. pressing ENTER on a card to add a new paragraph
-        // underneath. It's crucial not to pass a custom handler when
-        // isClickable is disabled which in the case of RT it's.
-        props.isClickable ? (e)=>{
+        onClick: props.isClickable ? (e)=>{
             e.preventDefault();
             if (props.onClick) return props.onClick(e);
             props.onEdit && props.onEdit();

package/dist/esm/resources/Cards/ContentfulEntryCard.js

@@ -1,10 +1,8 @@
 import * as React from 'react';
 import { WrappedEntryCard } from '../../entries';
-// assets are not shown for small cards (which we hardcode currently)
 const resolveAsset = ()=>Promise.resolve();
-// we don't want to show scheduled actions for resources
 const resolveScheduledActions = ()=>Promise.resolve([]);
-export function ContentfulEntryCard({ info, isDisabled, renderDragHandle, onRemove, onMoveTop, onMoveBottom, getEntryRouteHref }) {
+export function ContentfulEntryCard({ info , isDisabled , renderDragHandle , onRemove , onMoveTop , onMoveBottom , getEntryRouteHref  }) {
     const resourceSys = info.resource.sys;
     const spaceId = resourceSys.space.sys.id;
     const environmentId = resourceSys.environment.sys.id;
@@ -14,19 +12,14 @@ export function ContentfulEntryCard({ info, isDisabled, renderDragHandle, onRemo
         environmentId,
         entryId
     });
-    // TODO: move this into `sdk.navigator.openEntry()`, note that it's signature only include the entry id (not a space or environment)
     const openEntryDetail = ()=>{
         window.open(resourceHref, '_blank', 'noopener,noreferrer');
     };
-    return /*#__PURE__*/ React.createElement(WrappedEntryCard, {
+    return React.createElement(WrappedEntryCard, {
         entry: info.resource,
         isDisabled: isDisabled,
         hasCardEditActions: false,
         contentType: info.contentType,
-        // we use the default locale from the space the entry belongs to
-        // as we assume this gives a more consistent behaviour.
-        // locales will inevitably differ from space to space, so it's likely
-        // that the current locale does not exist in the "remote" space
         localeCode: info.defaultLocaleCode,
         defaultLocaleCode: info.defaultLocaleCode,
         size: "small",

package/dist/esm/resources/Cards/ResourceCard.js

@@ -5,29 +5,28 @@ import { useResource } from '../../common/EntityStore';
 import { ResourceEntityErrorCard } from '../../components';
 import { ContentfulEntryCard } from './ContentfulEntryCard';
 function ResourceCardSkeleton() {
-    return /*#__PURE__*/ React.createElement(EntryCard, {
+    return React.createElement(EntryCard, {
         size: "small",
         isLoading: true
     });
 }
 function ExistingResourceCard(props) {
-    const { resourceLink, inView, index = 0 } = props;
+    const { resourceLink , inView , index =0  } = props;
     const resourceOptions = {
         priority: index * -1,
         enabled: inView
     };
-    const { data, error } = useResource(resourceLink.sys.linkType, resourceLink.sys.urn, resourceOptions);
+    const { data , error  } = useResource(resourceLink.sys.linkType, resourceLink.sys.urn, resourceOptions);
     if (!data && !error) {
-        return /*#__PURE__*/ React.createElement(ResourceCardSkeleton, null);
+        return React.createElement(ResourceCardSkeleton, null);
     }
     if (data) {
-        // @ts-expect-error
-        return /*#__PURE__*/ React.createElement(ContentfulEntryCard, {
+        return React.createElement(ContentfulEntryCard, {
             info: data,
             ...props
         });
     }
-    return /*#__PURE__*/ React.createElement(ResourceEntityErrorCard, {
+    return React.createElement(ResourceEntityErrorCard, {
         linkType: resourceLink.sys.linkType,
         error: error,
         isDisabled: props.isDisabled,
@@ -38,21 +37,20 @@ function ResourceCardWrapper(props) {
     if (!props.resourceLink) {
         return null;
     }
-    return /*#__PURE__*/ React.createElement(ExistingResourceCard, {
+    return React.createElement(ExistingResourceCard, {
         ...props,
         resourceLink: props.resourceLink,
         getEntryRouteHref: props.getEntryRouteHref
     });
 }
 export function ResourceCard(props) {
-    const { ref, inView } = useInView({
+    const { ref , inView  } = useInView({
         triggerOnce: true,
         rootMargin: '300px 0px 0px 300px'
     });
-    // Forma does not offer us to pass refs, so we need an additional wrapper here
-    return /*#__PURE__*/ React.createElement("div", {
+    return React.createElement("div", {
         ref: ref
-    }, /*#__PURE__*/ React.createElement(ResourceCardWrapper, {
+    }, React.createElement(ResourceCardWrapper, {
         ...props,
         inView: inView
     }));

package/dist/esm/resources/Cards/ResourceCard.spec.js

@@ -14,7 +14,6 @@ configure({
 jest.mock('react-intersection-observer', ()=>({
         useInView: jest.fn().mockReturnValue({})
     }));
-// explicit master
 const resolvableEntryUrn = 'crn:contentful:::content:spaces/space-id/entries/linked-entry-urn';
 const resolvableEntryUrnWithExplicitMaster = 'crn:contentful:::content:spaces/space-id/environments/master/entries/linked-entry-urn';
 const resolvableEntryUrnWithAnotherEnvironment = 'crn:contentful:::content:spaces/space-id/environments/my-test-environment/entries/linked-entry-urn';
@@ -28,7 +27,7 @@ const sdk = {
             get: jest.fn().mockReturnValue(publishedCT)
         },
         Entry: {
-            get: jest.fn().mockImplementation(({ spaceId, environmentId, entryId })=>{
+            get: jest.fn().mockImplementation(({ spaceId , environmentId , entryId  })=>{
                 if (spaceId === 'space-id' && environmentId === 'master' && entryId === 'linked-entry-urn') {
                     return Promise.resolve(publishedEntry);
                 }
@@ -67,10 +66,10 @@ const sdk = {
         environment: 'environment-id'
     }
 };
-function renderResourceCard({ linkType = 'Contentful:Entry', entryUrn = resolvableEntryUrn } = {}) {
-    return render(/*#__PURE__*/ React.createElement(EntityProvider, {
+function renderResourceCard({ linkType ='Contentful:Entry' , entryUrn =resolvableEntryUrn  } = {}) {
+    return render(React.createElement(EntityProvider, {
         sdk: sdk
-    }, /*#__PURE__*/ React.createElement(ResourceCard, {
+    }, React.createElement(ResourceCard, {
         isDisabled: false,
         getEntryRouteHref: ()=>'',
         resourceLink: {
@@ -84,7 +83,7 @@ function renderResourceCard({ linkType = 'Contentful:Entry', entryUrn = resolvab
 }
 describe('ResourceCard', ()=>{
     it('renders entry card with implicit master crn', async ()=>{
-        const { getByTestId, getByText } = renderResourceCard();
+        const { getByTestId , getByText  } = renderResourceCard();
         const tooltipContent = `Space: ${space.name} (Env.: ${publishedEntry.sys.environment.sys.id})`;
         await waitFor(()=>expect(getByTestId('cf-ui-entry-card')).toBeDefined());
         expect(getByText(publishedEntry.fields.exField['en-US'])).toBeDefined();
@@ -93,7 +92,7 @@ describe('ResourceCard', ()=>{
         await waitFor(()=>expect(getByText(tooltipContent)).toBeDefined());
     });
     it('renders entry card with explicit master crn', async ()=>{
-        const { getByTestId, getByText } = renderResourceCard({
+        const { getByTestId , getByText  } = renderResourceCard({
             entryUrn: resolvableEntryUrnWithExplicitMaster
         });
         const tooltipContent = `Space: ${space.name} (Env.: ${publishedEntry.sys.environment.sys.id})`;
@@ -104,7 +103,7 @@ describe('ResourceCard', ()=>{
         await waitFor(()=>expect(getByText(tooltipContent)).toBeDefined());
     });
     it('renders entry card with a non master environment', async ()=>{
-        const { getByTestId, getByText } = renderResourceCard({
+        const { getByTestId , getByText  } = renderResourceCard({
             entryUrn: resolvableEntryUrnWithAnotherEnvironment
         });
         await waitFor(()=>expect(getByTestId('cf-ui-entry-card')).toBeDefined());
@@ -115,23 +114,23 @@ describe('ResourceCard', ()=>{
         await waitFor(()=>expect(getByText(tooltipContent)).toBeDefined());
     });
     it('renders skeleton when no data is provided', ()=>{
-        const { getByTestId } = renderResourceCard();
+        const { getByTestId  } = renderResourceCard();
         expect(getByTestId('cf-ui-skeleton-form')).toBeDefined();
     });
     it('renders unsupported entity card when unsupported link is passed', async ()=>{
-        const { getByText } = renderResourceCard({
+        const { getByText  } = renderResourceCard({
             linkType: 'Contentful:UnsupportedLink'
         });
         await waitFor(()=>expect(getByText('Resource type Contentful:UnsupportedLink is currently not supported')).toBeDefined());
     });
     it('renders missing entity card when unknown error is returned', async ()=>{
-        const { getByTestId } = renderResourceCard({
+        const { getByTestId  } = renderResourceCard({
             entryUrn: unknownEntryUrn
         });
         await waitFor(()=>expect(getByTestId('cf-ui-missing-entry-card')).toBeDefined());
     });
     it('renders missing entity card when crn is invalid', async ()=>{
-        const { getByTestId } = renderResourceCard({
+        const { getByTestId  } = renderResourceCard({
             entryUrn: ''
         });
         await waitFor(()=>expect(getByTestId('cf-ui-missing-entry-card')).toBeDefined());

package/dist/esm/resources/MultipleResourceReferenceEditor.js

@@ -10,9 +10,9 @@ import { CombinedLinkEntityActions } from '../components/LinkActions/LinkEntityA
 import { ResourceCard } from './Cards/ResourceCard';
 import { useResourceLinkActions } from './useResourceLinkActions';
 function ResourceEditor(props) {
-    const { setValue, items, apiUrl } = props;
+    const { setValue , items , apiUrl  } = props;
     const onSortStart = ()=>noop();
-    const onSortEnd = useCallback(({ oldIndex, newIndex })=>{
+    const onSortEnd = useCallback(({ oldIndex , newIndex  })=>{
         const newItems = arrayMove(items, oldIndex, newIndex);
         setValue(newItems);
     }, [
@@ -32,25 +32,24 @@ function ResourceEditor(props) {
         items,
         setValue
     ]);
-    const { dialogs, field } = props.sdk;
+    const { dialogs , field  } = props.sdk;
     const linkActionsProps = useResourceLinkActions({
         dialogs,
         field,
         apiUrl
     });
-    return /*#__PURE__*/ React.createElement(React.Fragment, null, props.children({
+    return React.createElement(React.Fragment, null, props.children({
         ...props,
         onSortStart,
         onSortEnd,
         onMove,
         onRemoteItemAtIndex
-    }), /*#__PURE__*/ React.createElement(CombinedLinkEntityActions, {
+    }), React.createElement(CombinedLinkEntityActions, {
         ...linkActionsProps,
         renderCustomActions: props.renderCustomActions
     }));
 }
-// provides memoized callbacks bound to a given item
-function WithPerItemCallbacks({ listLength, index, onMove, onRemoteItemAtIndex, children }) {
+function WithPerItemCallbacks({ listLength , index , onMove , onRemoteItemAtIndex , children  }) {
     const handleMoveTop = React.useMemo(()=>index > 0 ? ()=>onMove(index, 0) : undefined, [
         index,
         onMove
@@ -64,7 +63,7 @@ function WithPerItemCallbacks({ listLength, index, onMove, onRemoteItemAtIndex,
         index,
         onRemoteItemAtIndex
     ]);
-    return /*#__PURE__*/ React.createElement(React.Fragment, null, children({
+    return React.createElement(React.Fragment, null, children({
         onMoveBottom: handleMoveBottom,
         onMoveTop: handleMoveTop,
         onRemove: handleRemove
@@ -72,28 +71,28 @@ function WithPerItemCallbacks({ listLength, index, onMove, onRemoteItemAtIndex,
 }
 const EMPTY_ARRAY = [];
 export function MultipleResourceReferenceEditor(props) {
-    return /*#__PURE__*/ React.createElement(EntityProvider, {
+    return React.createElement(EntityProvider, {
         sdk: props.sdk
-    }, /*#__PURE__*/ React.createElement(FieldConnector, {
+    }, React.createElement(FieldConnector, {
         debounce: 0,
         field: props.sdk.field,
         isInitiallyDisabled: props.isInitiallyDisabled,
         isEqualValues: deepEqual
-    }, ({ value, disabled, setValue, externalReset })=>{
-        return /*#__PURE__*/ React.createElement(ResourceEditor, {
+    }, ({ value , disabled , setValue , externalReset  })=>{
+        return React.createElement(ResourceEditor, {
             ...props,
             items: value || EMPTY_ARRAY,
             isDisabled: disabled,
             setValue: setValue,
             renderCustomActions: props.renderCustomActions,
             key: `${externalReset}-list`
-        }, (editorProps)=>/*#__PURE__*/ React.createElement(SortableLinkList, editorProps, ({ item, isDisabled, DragHandle, index })=>/*#__PURE__*/ React.createElement(WithPerItemCallbacks, {
+        }, (editorProps)=>React.createElement(SortableLinkList, editorProps, ({ item , isDisabled , DragHandle , index  })=>React.createElement(WithPerItemCallbacks, {
                     key: index,
                     index: index,
                     onMove: editorProps.onMove,
                     onRemoteItemAtIndex: editorProps.onRemoteItemAtIndex,
                     listLength: value?.length || 0
-                }, ({ onMoveBottom, onMoveTop, onRemove })=>/*#__PURE__*/ React.createElement(ResourceCard, {
+                }, ({ onMoveBottom , onMoveTop , onRemove  })=>React.createElement(ResourceCard, {
                         key: index,
                         index: index,
                         resourceLink: item,