@contentful/field-editor-reference 5.19.0 → 5.20.0

package/dist/esm/components/MissingEntityCard/MissingEntityCard.js

@@ -3,20 +3,20 @@ import { Card, Flex, IconButton, SectionHeading } from '@contentful/f36-componen
 import { CloseIcon } from '@contentful/f36-icons';
 import * as styles from './styles';
 export function MissingEntityCard(props) {
-    return React.createElement(Card, {
+    return /*#__PURE__*/ React.createElement(Card, {
         className: styles.card,
         testId: "cf-ui-missing-entry-card",
         isSelected: props.isSelected
-    }, React.createElement(Flex, {
+    }, /*#__PURE__*/ React.createElement(Flex, {
         alignItems: "center",
         justifyContent: "space-between"
-    }, React.createElement("div", {
+    }, /*#__PURE__*/ React.createElement("div", {
         className: props.asSquare ? styles.squareCard : ''
-    }, React.createElement(SectionHeading, {
+    }, /*#__PURE__*/ React.createElement(SectionHeading, {
         marginBottom: "none"
-    }, props.entityType, " is missing or inaccessible")), !props.isDisabled && props.onRemove && React.createElement(IconButton, {
+    }, props.entityType, " is missing or inaccessible")), !props.isDisabled && props.onRemove && /*#__PURE__*/ React.createElement(IconButton, {
         variant: "transparent",
-        icon: React.createElement(CloseIcon, {
+        icon: /*#__PURE__*/ React.createElement(CloseIcon, {
             variant: "muted"
         }),
         "aria-label": "Delete",

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 React.createElement(UnsupportedEntityCard, {
+        return /*#__PURE__*/ React.createElement(UnsupportedEntityCard, {
             linkType: props.linkType,
             isSelected: props.isSelected
         });
     }
-    return React.createElement(MissingEntityCard, {
+    return /*#__PURE__*/ 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 React.createElement(Card, {
+    return /*#__PURE__*/ React.createElement(Card, {
         className: styles.card,
         isSelected: props.isSelected
-    }, React.createElement(SectionHeading, {
+    }, /*#__PURE__*/ 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 React.createElement(Tooltip, {
+export const ScheduleTooltip = ({ job, jobsCount, children })=>{
+    return /*#__PURE__*/ 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,6 +16,9 @@ export const ScheduledIconWithTooltip = ({ entityType , entityId , getEntitySche
                 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;
@@ -25,7 +28,7 @@ export const ScheduledIconWithTooltip = ({ entityType , entityId , getEntitySche
         return null;
     }
     const mostRelevantJob = jobs[0];
-    return React.createElement(ScheduleTooltip, {
+    return /*#__PURE__*/ React.createElement(ScheduleTooltip, {
         job: mostRelevantJob,
         jobsCount: jobs.length
     }, children);

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

@@ -1,5 +1,9 @@
+// eslint-disable-next-line -- TODO: describe this disable  no-restricted-imports
 import moment from 'moment';
-export const formatDate = (date, short)=>{
+/**
+ * @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)=>{
     switch(moment().startOf('day').diff(moment(date).startOf('day'), 'days')){
         case 0:
             return short ? 'Today' : `Today, ${moment(date).format('DD MMM YYYY')}`;
@@ -11,7 +15,12 @@ export const formatDate = (date, short)=>{
             return moment(date).format('ddd, DD MMM YYYY');
     }
 };
-export const formatTime = (date)=>{
+/**
+ * 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)=>{
     return moment.utc(date).local().format('h:mm A');
 };
 export const formatDateAndTime = (date, short)=>{

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

@@ -21,19 +21,19 @@ const styles = {
 export function SpaceName(props) {
     let content = `Space: ${props.spaceName}`;
     if (props.environmentName) content += ` (Env.: ${props.environmentName})`;
-    return React.createElement(Tooltip, {
+    return /*#__PURE__*/ React.createElement(Tooltip, {
         placement: "top",
         as: "div",
         content: content
-    }, React.createElement(Flex, {
+    }, /*#__PURE__*/ React.createElement(Flex, {
         alignItems: "center",
         gap: "spacingXs",
         marginRight: "spacingS"
-    }, React.createElement(FolderOpenTrimmedIcon, {
+    }, /*#__PURE__*/ React.createElement(FolderOpenTrimmedIcon, {
         className: styles.spaceIcon,
         size: "tiny",
         "aria-label": "Source space"
-    }), React.createElement(Text, {
+    }), /*#__PURE__*/ 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 React.createElement(MultipleReferenceEditor, {
+    return /*#__PURE__*/ React.createElement(MultipleReferenceEditor, {
         ...props,
         entityType: "Entry",
         setIndexToUpdate: setIndexToUpdate
-    }, (childrenProps)=>React.createElement(SortableLinkList, {
+    }, (childrenProps)=>/*#__PURE__*/ React.createElement(SortableLinkList, {
             ...childrenProps,
             sortingStrategy: verticalListSortingStrategy,
             updateBeforeSortStart: updateBeforeSortStart
-        }, ({ items , item , index , isDisabled , DragHandle  })=>{
+        }, ({ items, item, index, isDisabled, DragHandle })=>{
             const lastIndex = items.length - 1;
-            return React.createElement(FetchingWrappedEntryCard, {
+            return /*#__PURE__*/ 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 React.createElement(SingleReferenceEditor, {
+    return /*#__PURE__*/ React.createElement(SingleReferenceEditor, {
         ...props,
         entityType: "Entry"
-    }, ({ allContentTypes , isDisabled , entityId , setValue , renderCustomCard , hasCardRemoveActions , hasCardEditActions  })=>{
-        return React.createElement(FetchingWrappedEntryCard, {
+    }, ({ allContentTypes, isDisabled, entityId, setValue, renderCustomCard, hasCardRemoveActions, hasCardEditActions })=>{
+        return /*#__PURE__*/ React.createElement(FetchingWrappedEntryCard, {
             ...props,
             allContentTypes: allContentTypes,
             isDisabled: isDisabled,

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

@@ -15,7 +15,10 @@ async function openEntry(sdk, entryId, options) {
             });
             slide = result.slide;
             return slide;
-        } catch (e) {}
+        } catch (e) {
+        // we don't allow to open multiple bulk editors for performance reasons
+        // proceed with a default openEntry
+        }
     }
     const result = await sdk.navigator.openEntry(entryId, {
         slideIn: true
@@ -24,14 +27,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, {
@@ -62,12 +65,13 @@ 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 = React.createElement(MissingEntityCard, {
+            const card = /*#__PURE__*/ React.createElement(MissingEntityCard, {
                 entityType: "Entry",
                 isDisabled: props.isDisabled,
                 onRemove: onRemoveEntry
@@ -84,7 +88,7 @@ export function FetchingWrappedEntryCard(props) {
             return card;
         }
         if (status === 'loading') {
-            return React.createElement(EntryCard, {
+            return /*#__PURE__*/ React.createElement(EntryCard, {
                 size: size,
                 isLoading: true
             });
@@ -105,7 +109,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,
@@ -118,15 +122,18 @@ export function FetchingWrappedEntryCard(props) {
                 entry: (props?.entity) || sharedCardProps.entity,
                 entryUrl: props?.entityUrl || sharedCardProps.entityUrl
             };
-            return React.createElement(WrappedEntryCard, builtinCardProps);
+            return /*#__PURE__*/ 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 React.createElement(MissingEntityCard, {
+        return /*#__PURE__*/ 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 React.createElement(EntryCard, {
+    return /*#__PURE__*/ React.createElement(EntryCard, {
         as: props.entryUrl ? 'a' : 'article',
         href: props.entryUrl,
         title: title,
@@ -71,54 +71,58 @@ export function WrappedEntryCard(props) {
         size: props.size,
         isSelected: props.isSelected,
         status: status,
-        icon: props.spaceName ? React.createElement(SpaceName, {
+        icon: props.spaceName ? /*#__PURE__*/ React.createElement(SpaceName, {
             spaceName: props.spaceName,
             environmentName: props.entry.sys.environment.sys.id
-        }) : React.createElement(ScheduledIconWithTooltip, {
+        }) : /*#__PURE__*/ React.createElement(ScheduledIconWithTooltip, {
             getEntityScheduledActions: props.getEntityScheduledActions,
             entityType: "Entry",
             entityId: props.entry.sys.id
-        }, React.createElement(ClockIcon, {
+        }, /*#__PURE__*/ React.createElement(ClockIcon, {
             className: styles.scheduleIcon,
             size: "small",
             variant: "muted",
             testId: "schedule-icon"
         })),
-        thumbnailElement: file && isValidImage(file) ? React.createElement(AssetThumbnail, {
+        thumbnailElement: file && isValidImage(file) ? /*#__PURE__*/ React.createElement(AssetThumbnail, {
             file: file
         }) : undefined,
         dragHandleRender: props.renderDragHandle,
         withDragHandle: !!props.renderDragHandle,
         actions: props.onEdit || props.onRemove ? [
-            props.hasCardEditActions && props.onEdit ? React.createElement(MenuItem, {
+            props.hasCardEditActions && props.onEdit ? /*#__PURE__*/ React.createElement(MenuItem, {
                 key: "edit",
                 testId: "edit",
                 onClick: ()=>{
                     props.onEdit && props.onEdit();
                 }
             }, "Edit") : null,
-            props.hasCardRemoveActions && props.onRemove ? React.createElement(MenuItem, {
+            props.hasCardRemoveActions && props.onRemove ? /*#__PURE__*/ React.createElement(MenuItem, {
                 key: "delete",
                 testId: "delete",
                 onClick: ()=>{
                     props.onRemove && props.onRemove();
                 }
             }, "Remove") : null,
-            props.hasCardMoveActions && (props.onMoveTop || props.onMoveBottom) ? React.createElement(MenuDivider, {
+            props.hasCardMoveActions && (props.onMoveTop || props.onMoveBottom) ? /*#__PURE__*/ React.createElement(MenuDivider, {
                 key: "divider"
             }) : null,
-            props.hasCardMoveActions && props.onMoveTop ? React.createElement(MenuItem, {
+            props.hasCardMoveActions && props.onMoveTop ? /*#__PURE__*/ React.createElement(MenuItem, {
                 key: "move-top",
                 onClick: ()=>props.onMoveTop && props.onMoveTop(),
                 testId: "move-top"
             }, "Move to top") : null,
-            props.hasCardMoveActions && props.onMoveBottom ? React.createElement(MenuItem, {
+            props.hasCardMoveActions && props.onMoveBottom ? /*#__PURE__*/ React.createElement(MenuItem, {
                 key: "move-bottom",
                 onClick: ()=>props.onMoveBottom && props.onMoveBottom(),
                 testId: "move-bottom"
             }, "Move to bottom") : null
         ].filter((item)=>item) : [],
-        onClick: props.isClickable ? (e)=>{
+        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)=>{
             e.preventDefault();
             if (props.onClick) return props.onClick(e);
             props.onEdit && props.onEdit();

package/dist/esm/index.js

@@ -3,5 +3,6 @@ export { SingleEntryReferenceEditor, MultipleEntryReferenceEditor, WrappedEntryC
 export { SingleMediaEditor, MultipleMediaEditor, WrappedAssetCard } from './assets';
 export { SortableLinkList } from './common/SortableLinkList';
 export { EntityProvider, useEntityLoader, useEntity, useResource } from './common/EntityStore';
+export { SharedQueryClientProvider as EntityCacheProvider } from './common/queryClient';
 export { SingleResourceReferenceEditor, MultipleResourceReferenceEditor } from './resources';
 export * from './types';

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

@@ -1,8 +1,10 @@
 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;
@@ -12,14 +14,19 @@ export function ContentfulEntryCard({ info , isDisabled , renderDragHandle , onR
         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 React.createElement(WrappedEntryCard, {
+    return /*#__PURE__*/ 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,28 +5,29 @@ import { useResource } from '../../common/EntityStore';
 import { ResourceEntityErrorCard } from '../../components';
 import { ContentfulEntryCard } from './ContentfulEntryCard';
 function ResourceCardSkeleton() {
-    return React.createElement(EntryCard, {
+    return /*#__PURE__*/ 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 React.createElement(ResourceCardSkeleton, null);
+        return /*#__PURE__*/ React.createElement(ResourceCardSkeleton, null);
     }
     if (data) {
-        return React.createElement(ContentfulEntryCard, {
+        // @ts-expect-error
+        return /*#__PURE__*/ React.createElement(ContentfulEntryCard, {
             info: data,
             ...props
         });
     }
-    return React.createElement(ResourceEntityErrorCard, {
+    return /*#__PURE__*/ React.createElement(ResourceEntityErrorCard, {
         linkType: resourceLink.sys.linkType,
         error: error,
         isDisabled: props.isDisabled,
@@ -37,20 +38,21 @@ function ResourceCardWrapper(props) {
     if (!props.resourceLink) {
         return null;
     }
-    return React.createElement(ExistingResourceCard, {
+    return /*#__PURE__*/ 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'
     });
-    return React.createElement("div", {
+    // Forma does not offer us to pass refs, so we need an additional wrapper here
+    return /*#__PURE__*/ React.createElement("div", {
         ref: ref
-    }, React.createElement(ResourceCardWrapper, {
+    }, /*#__PURE__*/ React.createElement(ResourceCardWrapper, {
         ...props,
         inView: inView
     }));

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

@@ -14,6 +14,7 @@ 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';
@@ -27,7 +28,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);
                 }
@@ -66,10 +67,10 @@ const sdk = {
         environment: 'environment-id'
     }
 };
-function renderResourceCard({ linkType ='Contentful:Entry' , entryUrn =resolvableEntryUrn  } = {}) {
-    return render(React.createElement(EntityProvider, {
+function renderResourceCard({ linkType = 'Contentful:Entry', entryUrn = resolvableEntryUrn } = {}) {
+    return render(/*#__PURE__*/ React.createElement(EntityProvider, {
         sdk: sdk
-    }, React.createElement(ResourceCard, {
+    }, /*#__PURE__*/ React.createElement(ResourceCard, {
         isDisabled: false,
         getEntryRouteHref: ()=>'',
         resourceLink: {
@@ -83,7 +84,7 @@ function renderResourceCard({ linkType ='Contentful:Entry' , entryUrn =resolvabl
 }
 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();
@@ -92,7 +93,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})`;
@@ -103,7 +104,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());
@@ -114,23 +115,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());