@contentful/field-editor-reference 5.13.3 → 5.15.0

package/dist/cjs/common/EntityStore.js

@@ -29,10 +29,10 @@ _export(exports, {
     }
 });
 const _react = _interop_require_wildcard(require("react"));
-const _reactquery = require("@tanstack/react-query");
 const _constate = _interop_require_default(require("constate"));
 const _contentfulmanagement = require("contentful-management");
 const _pqueue = _interop_require_default(require("p-queue"));
+const _queryClient = require("./queryClient");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -109,8 +109,14 @@ const isEntityQueryKey = (queryKey)=>{
 async function fetchContentfulEntry(params) {
     const { urn , fetch , options  } = params;
     const resourceId = urn.split(':', 6)[5];
-    const [, spaceId, , entryId] = resourceId.split('/');
-    const environmentId = 'master';
+    const ENTITY_RESOURCE_ID_REGEX = RegExp("^spaces\\/(?<spaceId>[^/]+)(?:\\/environments\\/(?<environmentId>[^/]+))?\\/entries\\/(?<entityId>[^/]+)$");
+    const resourceIdMatch = resourceId.match(ENTITY_RESOURCE_ID_REGEX);
+    if (!resourceIdMatch || !resourceIdMatch?.groups?.spaceId || !resourceIdMatch?.groups?.entityId) {
+        throw new Error('Not a valid crn');
+    }
+    const spaceId = resourceIdMatch.groups.spaceId;
+    const environmentId = resourceIdMatch?.groups?.environmentId || 'master';
+    const entryId = resourceIdMatch.groups.entityId;
     const [space, entry] = await Promise.all([
         fetch([
             'space',
@@ -174,7 +180,7 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = (0,
         props.sdk.ids.environmentAlias,
         props.sdk.ids.environment
     ]);
-    const queryClient = (0, _reactquery.useQueryClient)();
+    const queryClient = (0, _queryClient.useQueryClient)();
     const queryCache = queryClient.getQueryCache();
     const entityChangeUnsubscribers = (0, _react.useRef)({});
     const cmaClient = (0, _react.useMemo)(()=>(0, _contentfulmanagement.createClient)({
@@ -372,7 +378,7 @@ function useEntity(entityType, entityId, options) {
         options?.spaceId ?? space,
         options?.environmentId ?? environment
     ];
-    const { status , data  } = (0, _reactquery.useQuery)(queryKey, ()=>getEntity(entityType, entityId, options), {
+    const { status , data  } = (0, _queryClient.useQuery)(queryKey, ()=>getEntity(entityType, entityId, options), {
         enabled: options?.enabled
     });
     return {
@@ -387,7 +393,7 @@ function useResource(resourceType, urn, options) {
         urn
     ];
     const { getResource  } = useEntityLoader();
-    const { status , data , error  } = (0, _reactquery.useQuery)(queryKey, ()=>getResource(resourceType, urn, options), {
+    const { status , data , error  } = (0, _queryClient.useQuery)(queryKey, ()=>getResource(resourceType, urn, options), {
         enabled: options?.enabled
     });
     return {
@@ -397,24 +403,5 @@ function useResource(resourceType, urn, options) {
     };
 }
 function EntityProvider({ children , ...props }) {
-    const reactQueryClient = (0, _react.useMemo)(()=>{
-        const queryCache = new _reactquery.QueryCache();
-        const queryClient = new _reactquery.QueryClient({
-            queryCache,
-            defaultOptions: {
-                queries: {
-                    useErrorBoundary: false,
-                    refetchOnWindowFocus: false,
-                    refetchOnReconnect: true,
-                    refetchOnMount: false,
-                    staleTime: Infinity,
-                    retry: false
-                }
-            }
-        });
-        return queryClient;
-    }, []);
-    return _react.default.createElement(_reactquery.QueryClientProvider, {
-        client: reactQueryClient
-    }, _react.default.createElement(InternalServiceProvider, props, children));
+    return _react.default.createElement(_queryClient.SharedQueryClientProvider, null, _react.default.createElement(InternalServiceProvider, props, children));
 }

package/dist/cjs/common/queryClient.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    useQueryClient: function() {
+        return useQueryClient;
+    },
+    useQuery: function() {
+        return useQuery;
+    },
+    SharedQueryClientProvider: function() {
+        return SharedQueryClientProvider;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _reactquery = require("@tanstack/react-query");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const clientContext = _react.createContext(undefined);
+function useQueryClient() {
+    const client = _react.useContext(clientContext);
+    return _react.useMemo(()=>{
+        if (client) {
+            return client;
+        }
+        return new _reactquery.QueryClient({
+            defaultOptions: {
+                queries: {
+                    useErrorBoundary: false,
+                    refetchOnWindowFocus: false,
+                    refetchOnReconnect: true,
+                    refetchOnMount: false,
+                    staleTime: Infinity,
+                    retry: false
+                }
+            }
+        });
+    }, [
+        client
+    ]);
+}
+const useQuery = (key, fn, opt)=>{
+    return (0, _reactquery.useQuery)(key, fn, {
+        ...opt,
+        context: clientContext
+    });
+};
+function SharedQueryClientProvider({ children  }) {
+    const client = useQueryClient();
+    return _react.createElement(clientContext.Provider, {
+        value: client
+    }, children);
+}

package/dist/cjs/components/SpaceName/SpaceName.js

@@ -60,12 +60,12 @@ function _interop_require_wildcard(obj, nodeInterop) {
 const styles = {
     spaceIcon: (0, _emotion.css)({
         flexShrink: 0,
-        fill: _f36tokens.default.purple600
+        fill: _f36tokens.default.gray600
     }),
     spaceName: (0, _emotion.css)({
-        color: _f36tokens.default.gray700,
+        color: _f36tokens.default.gray600,
         fontSize: _f36tokens.default.fontSizeS,
-        fontWeight: _f36tokens.default.fontWeightDemiBold,
+        fontWeight: _f36tokens.default.fontWeightMedium,
         maxWidth: '80px',
         textOverflow: 'ellipsis',
         overflow: 'hidden',
@@ -73,10 +73,12 @@ const styles = {
     })
 };
 function SpaceName(props) {
+    let content = `Space: ${props.spaceName}`;
+    if (props.environmentName) content += ` (Env.: ${props.environmentName})`;
     return _react.createElement(_f36components.Tooltip, {
         placement: "top",
         as: "div",
-        content: `Space: ${props.spaceName}`
+        content: content
     }, _react.createElement(_f36components.Flex, {
         alignItems: "center",
         gap: "spacingXs",

package/dist/cjs/entries/WrappedEntryCard/WrappedEntryCard.js

@@ -126,7 +126,8 @@ function WrappedEntryCard(props) {
         isSelected: props.isSelected,
         status: status,
         icon: props.spaceName ? _react.createElement(_SpaceName.SpaceName, {
-            spaceName: props.spaceName
+            spaceName: props.spaceName,
+            environmentName: props.entry.sys.environment.sys.id
         }) : _react.createElement(_components.ScheduledIconWithTooltip, {
             getEntityScheduledActions: props.getEntityScheduledActions,
             entityType: "Entry",

package/dist/cjs/index.js

@@ -66,6 +66,9 @@ _export(exports, {
     useResource: function() {
         return _EntityStore.useResource;
     },
+    EntityCacheProvider: function() {
+        return _queryClient.SharedQueryClientProvider;
+    },
     SingleResourceReferenceEditor: function() {
         return _resources.SingleResourceReferenceEditor;
     },
@@ -78,6 +81,7 @@ const _entries = require("./entries");
 const _assets = require("./assets");
 const _SortableLinkList = require("./common/SortableLinkList");
 const _EntityStore = require("./common/EntityStore");
+const _queryClient = require("./common/queryClient");
 const _resources = require("./resources");
 _export_star(require("./types"), exports);
 function _export_star(from, to) {

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

@@ -7,6 +7,7 @@ require("@testing-library/jest-dom");
 const _fieldeditortestutils = require("@contentful/field-editor-test-utils");
 const _react1 = require("@testing-library/react");
 const _published_content_typejson = _interop_require_default(require("../../__fixtures__/content-type/published_content_type.json"));
+const _published_entry_non_masterjson = _interop_require_default(require("../../__fixtures__/entry/published_entry_non_master.json"));
 const _published_entryjson = _interop_require_default(require("../../__fixtures__/entry/published_entry.json"));
 const _indifferent_spacejson = _interop_require_default(require("../../__fixtures__/space/indifferent_space.json"));
 const _EntityStore = require("../../common/EntityStore");
@@ -62,6 +63,8 @@ jest.mock('react-intersection-observer', ()=>({
         useInView: jest.fn().mockReturnValue({})
     }));
 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';
 const unknownEntryUrn = 'crn:contentful:::content:spaces/space-id/entries/unknown-entry-urn';
 const sdk = {
     locales: {
@@ -72,10 +75,13 @@ const sdk = {
             get: jest.fn().mockReturnValue(_published_content_typejson.default)
         },
         Entry: {
-            get: jest.fn().mockImplementation(({ entryId  })=>{
-                if (entryId === 'linked-entry-urn') {
+            get: jest.fn().mockImplementation(({ spaceId , environmentId , entryId  })=>{
+                if (spaceId === 'space-id' && environmentId === 'master' && entryId === 'linked-entry-urn') {
                     return Promise.resolve(_published_entryjson.default);
                 }
+                if (spaceId === 'space-id' && environmentId === 'my-test-environment' && entryId === 'linked-entry-urn') {
+                    return Promise.resolve(_published_entry_non_masterjson.default);
+                }
                 return Promise.reject(new Error());
             })
         },
@@ -124,11 +130,36 @@ function renderResourceCard({ linkType ='Contentful:Entry' , entryUrn =resolvabl
     })));
 }
 describe('ResourceCard', ()=>{
-    it('renders entry card', async ()=>{
+    it('renders entry card with implicit master crn', async ()=>{
         const { getByTestId , getByText  } = renderResourceCard();
+        const tooltipContent = `Space: ${_indifferent_spacejson.default.name} (Env.: ${_published_entryjson.default.sys.environment.sys.id})`;
         await (0, _react1.waitFor)(()=>expect(getByTestId('cf-ui-entry-card')).toBeDefined());
         expect(getByText(_published_entryjson.default.fields.exField['en-US'])).toBeDefined();
         expect(getByText(_indifferent_spacejson.default.name)).toBeDefined();
+        _react1.fireEvent.mouseEnter(getByText(_indifferent_spacejson.default.name));
+        await (0, _react1.waitFor)(()=>expect(getByText(tooltipContent)).toBeDefined());
+    });
+    it('renders entry card with explicit master crn', async ()=>{
+        const { getByTestId , getByText  } = renderResourceCard({
+            entryUrn: resolvableEntryUrnWithExplicitMaster
+        });
+        const tooltipContent = `Space: ${_indifferent_spacejson.default.name} (Env.: ${_published_entryjson.default.sys.environment.sys.id})`;
+        await (0, _react1.waitFor)(()=>expect(getByTestId('cf-ui-entry-card')).toBeDefined());
+        expect(getByText(_published_entryjson.default.fields.exField['en-US'])).toBeDefined();
+        expect(getByText(_indifferent_spacejson.default.name)).toBeDefined();
+        _react1.fireEvent.mouseEnter(getByText(_indifferent_spacejson.default.name));
+        await (0, _react1.waitFor)(()=>expect(getByText(tooltipContent)).toBeDefined());
+    });
+    it('renders entry card with a non master environment', async ()=>{
+        const { getByTestId , getByText  } = renderResourceCard({
+            entryUrn: resolvableEntryUrnWithAnotherEnvironment
+        });
+        await (0, _react1.waitFor)(()=>expect(getByTestId('cf-ui-entry-card')).toBeDefined());
+        const tooltipContent = `Space: ${_indifferent_spacejson.default.name} (Env.: ${_published_entry_non_masterjson.default.sys.environment.sys.id})`;
+        expect(getByText(_published_entry_non_masterjson.default.fields.exField['en-US'])).toBeDefined();
+        expect(getByText(_indifferent_spacejson.default.name)).toBeDefined();
+        _react1.fireEvent.mouseEnter(getByText(_indifferent_spacejson.default.name));
+        await (0, _react1.waitFor)(()=>expect(getByText(tooltipContent)).toBeDefined());
     });
     it('renders skeleton when no data is provided', ()=>{
         const { getByTestId  } = renderResourceCard();
@@ -146,4 +177,10 @@ describe('ResourceCard', ()=>{
         });
         await (0, _react1.waitFor)(()=>expect(getByTestId('cf-ui-missing-entry-card')).toBeDefined());
     });
+    it('renders missing entity card when crn is invalid', async ()=>{
+        const { getByTestId  } = renderResourceCard({
+            entryUrn: ''
+        });
+        await (0, _react1.waitFor)(()=>expect(getByTestId('cf-ui-missing-entry-card')).toBeDefined());
+    });
 });

package/dist/esm/common/EntityStore.js

@@ -12,10 +12,10 @@ function _define_property(obj, key, value) {
     return obj;
 }
 import React, { useCallback, useEffect, useMemo, useRef } from 'react';
-import { QueryCache, QueryClient, QueryClientProvider, useQuery, useQueryClient } from '@tanstack/react-query';
 import constate from 'constate';
 import { createClient } from 'contentful-management';
 import PQueue from 'p-queue';
+import { SharedQueryClientProvider, useQuery, useQueryClient } from './queryClient';
 const globalQueue = new PQueue({
     concurrency: 50
 });
@@ -35,8 +35,14 @@ const isEntityQueryKey = (queryKey)=>{
 async function fetchContentfulEntry(params) {
     const { urn , fetch , options  } = params;
     const resourceId = urn.split(':', 6)[5];
-    const [, spaceId, , entryId] = resourceId.split('/');
-    const environmentId = 'master';
+    const ENTITY_RESOURCE_ID_REGEX = RegExp("^spaces\\/(?<spaceId>[^/]+)(?:\\/environments\\/(?<environmentId>[^/]+))?\\/entries\\/(?<entityId>[^/]+)$");
+    const resourceIdMatch = resourceId.match(ENTITY_RESOURCE_ID_REGEX);
+    if (!resourceIdMatch || !resourceIdMatch?.groups?.spaceId || !resourceIdMatch?.groups?.entityId) {
+        throw new Error('Not a valid crn');
+    }
+    const spaceId = resourceIdMatch.groups.spaceId;
+    const environmentId = resourceIdMatch?.groups?.environmentId || 'master';
+    const entryId = resourceIdMatch.groups.entityId;
     const [space, entry] = await Promise.all([
         fetch([
             'space',
@@ -323,25 +329,6 @@ export function useResource(resourceType, urn, options) {
     };
 }
 function EntityProvider({ children , ...props }) {
-    const reactQueryClient = useMemo(()=>{
-        const queryCache = new QueryCache();
-        const queryClient = new QueryClient({
-            queryCache,
-            defaultOptions: {
-                queries: {
-                    useErrorBoundary: false,
-                    refetchOnWindowFocus: false,
-                    refetchOnReconnect: true,
-                    refetchOnMount: false,
-                    staleTime: Infinity,
-                    retry: false
-                }
-            }
-        });
-        return queryClient;
-    }, []);
-    return React.createElement(QueryClientProvider, {
-        client: reactQueryClient
-    }, React.createElement(InternalServiceProvider, props, children));
+    return React.createElement(SharedQueryClientProvider, null, React.createElement(InternalServiceProvider, props, children));
 }
 export { EntityProvider, useEntityLoader };

package/dist/esm/common/queryClient.js

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { QueryClient, useQuery as useRQ } from '@tanstack/react-query';
+const clientContext = React.createContext(undefined);
+export function useQueryClient() {
+    const client = React.useContext(clientContext);
+    return React.useMemo(()=>{
+        if (client) {
+            return client;
+        }
+        return new QueryClient({
+            defaultOptions: {
+                queries: {
+                    useErrorBoundary: false,
+                    refetchOnWindowFocus: false,
+                    refetchOnReconnect: true,
+                    refetchOnMount: false,
+                    staleTime: Infinity,
+                    retry: false
+                }
+            }
+        });
+    }, [
+        client
+    ]);
+}
+export const useQuery = (key, fn, opt)=>{
+    return useRQ(key, fn, {
+        ...opt,
+        context: clientContext
+    });
+};
+export function SharedQueryClientProvider({ children  }) {
+    const client = useQueryClient();
+    return React.createElement(clientContext.Provider, {
+        value: client
+    }, children);
+}

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

@@ -6,12 +6,12 @@ import { css } from 'emotion';
 const styles = {
     spaceIcon: css({
         flexShrink: 0,
-        fill: tokens.purple600
+        fill: tokens.gray600
     }),
     spaceName: css({
-        color: tokens.gray700,
+        color: tokens.gray600,
         fontSize: tokens.fontSizeS,
-        fontWeight: tokens.fontWeightDemiBold,
+        fontWeight: tokens.fontWeightMedium,
         maxWidth: '80px',
         textOverflow: 'ellipsis',
         overflow: 'hidden',
@@ -19,10 +19,12 @@ const styles = {
     })
 };
 export function SpaceName(props) {
+    let content = `Space: ${props.spaceName}`;
+    if (props.environmentName) content += ` (Env.: ${props.environmentName})`;
     return React.createElement(Tooltip, {
         placement: "top",
         as: "div",
-        content: `Space: ${props.spaceName}`
+        content: content
     }, React.createElement(Flex, {
         alignItems: "center",
         gap: "spacingXs",

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

@@ -72,7 +72,8 @@ export function WrappedEntryCard(props) {
         isSelected: props.isSelected,
         status: status,
         icon: props.spaceName ? React.createElement(SpaceName, {
-            spaceName: props.spaceName
+            spaceName: props.spaceName,
+            environmentName: props.entry.sys.environment.sys.id
         }) : React.createElement(ScheduledIconWithTooltip, {
             getEntityScheduledActions: props.getEntityScheduledActions,
             entityType: "Entry",

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/ResourceCard.spec.js

@@ -1,8 +1,9 @@
 import * as React from 'react';
 import '@testing-library/jest-dom';
 import { createFakeCMAAdapter } from '@contentful/field-editor-test-utils';
-import { configure, render, waitFor } from '@testing-library/react';
+import { configure, fireEvent, render, waitFor } from '@testing-library/react';
 import publishedCT from '../../__fixtures__/content-type/published_content_type.json';
+import publishedEntryNonMasterEnvironment from '../../__fixtures__/entry/published_entry_non_master.json';
 import publishedEntry from '../../__fixtures__/entry/published_entry.json';
 import space from '../../__fixtures__/space/indifferent_space.json';
 import { EntityProvider } from '../../common/EntityStore';
@@ -14,6 +15,8 @@ jest.mock('react-intersection-observer', ()=>({
         useInView: jest.fn().mockReturnValue({})
     }));
 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';
 const unknownEntryUrn = 'crn:contentful:::content:spaces/space-id/entries/unknown-entry-urn';
 const sdk = {
     locales: {
@@ -24,10 +27,13 @@ const sdk = {
             get: jest.fn().mockReturnValue(publishedCT)
         },
         Entry: {
-            get: jest.fn().mockImplementation(({ entryId  })=>{
-                if (entryId === 'linked-entry-urn') {
+            get: jest.fn().mockImplementation(({ spaceId , environmentId , entryId  })=>{
+                if (spaceId === 'space-id' && environmentId === 'master' && entryId === 'linked-entry-urn') {
                     return Promise.resolve(publishedEntry);
                 }
+                if (spaceId === 'space-id' && environmentId === 'my-test-environment' && entryId === 'linked-entry-urn') {
+                    return Promise.resolve(publishedEntryNonMasterEnvironment);
+                }
                 return Promise.reject(new Error());
             })
         },
@@ -76,11 +82,36 @@ function renderResourceCard({ linkType ='Contentful:Entry' , entryUrn =resolvabl
     })));
 }
 describe('ResourceCard', ()=>{
-    it('renders entry card', async ()=>{
+    it('renders entry card with implicit master crn', async ()=>{
         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();
         expect(getByText(space.name)).toBeDefined();
+        fireEvent.mouseEnter(getByText(space.name));
+        await waitFor(()=>expect(getByText(tooltipContent)).toBeDefined());
+    });
+    it('renders entry card with explicit master crn', async ()=>{
+        const { getByTestId , getByText  } = renderResourceCard({
+            entryUrn: resolvableEntryUrnWithExplicitMaster
+        });
+        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();
+        expect(getByText(space.name)).toBeDefined();
+        fireEvent.mouseEnter(getByText(space.name));
+        await waitFor(()=>expect(getByText(tooltipContent)).toBeDefined());
+    });
+    it('renders entry card with a non master environment', async ()=>{
+        const { getByTestId , getByText  } = renderResourceCard({
+            entryUrn: resolvableEntryUrnWithAnotherEnvironment
+        });
+        await waitFor(()=>expect(getByTestId('cf-ui-entry-card')).toBeDefined());
+        const tooltipContent = `Space: ${space.name} (Env.: ${publishedEntryNonMasterEnvironment.sys.environment.sys.id})`;
+        expect(getByText(publishedEntryNonMasterEnvironment.fields.exField['en-US'])).toBeDefined();
+        expect(getByText(space.name)).toBeDefined();
+        fireEvent.mouseEnter(getByText(space.name));
+        await waitFor(()=>expect(getByText(tooltipContent)).toBeDefined());
     });
     it('renders skeleton when no data is provided', ()=>{
         const { getByTestId  } = renderResourceCard();
@@ -98,4 +129,10 @@ describe('ResourceCard', ()=>{
         });
         await waitFor(()=>expect(getByTestId('cf-ui-missing-entry-card')).toBeDefined());
     });
+    it('renders missing entity card when crn is invalid', async ()=>{
+        const { getByTestId  } = renderResourceCard({
+            entryUrn: ''
+        });
+        await waitFor(()=>expect(getByTestId('cf-ui-missing-entry-card')).toBeDefined());
+    });
 });

package/dist/types/common/EntityStore.d.ts

@@ -54,7 +54,7 @@ declare const useEntityLoader: () => {
 };
 export declare function useEntity<E extends FetchableEntity>(entityType: FetchableEntityType, entityId: string, options?: UseEntityOptions): UseEntityResult<E>;
 export declare function useResource(resourceType: ResourceType, urn: string, options?: UseResourceOptions): {
-    status: "loading" | "error" | "success";
+    status: "error" | "success" | "loading";
     data: ResourceInfo<Resource> | undefined;
     error: unknown;
 };

package/dist/types/common/queryClient.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { QueryClient, useQuery as useRQ } from '@tanstack/react-query';
+export declare function useQueryClient(): QueryClient;
+export declare const useQuery: typeof useRQ;
+/**
+ * Provides access to a query client either by sharing an existing client or
+ * creating a new one.
+ */
+export declare function SharedQueryClientProvider({ children }: React.PropsWithChildren<{}>): React.JSX.Element;

package/dist/types/components/SpaceName/SpaceName.d.ts

@@ -1,6 +1,7 @@
 import * as React from 'react';
-interface SpaceNameProps {
+interface SourceProps {
     spaceName: string;
+    environmentName?: string;
 }
-export declare function SpaceName(props: SpaceNameProps): React.JSX.Element;
+export declare function SpaceName(props: SourceProps): React.JSX.Element;
 export {};

package/dist/types/index.d.ts

@@ -5,6 +5,7 @@ export type { CustomActionProps } from './common/ReferenceEditor';
 export type { CustomEntityCardProps, DefaultCardRenderer, MissingEntityCardProps, RenderCustomMissingEntityCard, } from './common/customCardTypes';
 export { SortableLinkList } from './common/SortableLinkList';
 export { EntityProvider, useEntityLoader, useEntity, useResource } from './common/EntityStore';
+export { SharedQueryClientProvider as EntityCacheProvider } from './common/queryClient';
 export type { ResourceInfo } from './common/EntityStore';
 export { SingleResourceReferenceEditor, MultipleResourceReferenceEditor } from './resources';
 export * from './types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/field-editor-reference",
-  "version": "5.13.3",
+  "version": "5.15.0",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",
@@ -63,5 +63,5 @@
     "@contentful/app-sdk": "^4.2.0",
     "react": ">=16.8.0"
   },
-  "gitHead": "68039530d579ba49330f49e4c6be37823a774a29"
+  "gitHead": "780d4eb1450f777c2d2396a86d0b1a10268b3c13"
 }