@contentful/field-editor-reference 6.12.1 → 6.13.0

package/dist/esm/assets/WrappedAssetCard/FetchingWrappedAssetCard.js

@@ -1,30 +1,25 @@
 import * as React from 'react';
 import { AssetCard, EntryCard } from '@contentful/f36-components';
-import { useLocalePublishStatus, useActiveLocales, useActiveReleaseLocalesStatuses, parseReleaseParams, getEntityReleaseStatus } from '@contentful/field-editor-shared';
+import { useLocalePublishStatus, useActiveLocales, useReleaseStatus } from '@contentful/field-editor-shared';
 import { useEntity, useEntityLoader } from '../../common/EntityStore';
 import { MissingAssetCard } from '../../components';
 import { WrappedAssetCard } from './WrappedAssetCard';
 import { WrappedAssetLink } from './WrappedAssetLink';
 export function FetchingWrappedAssetCard(props) {
-    const { releaseVersionMap, locales, activeRelease, releases, isActiveReleaseLoading } = parseReleaseParams(props.sdk.parameters.instance.release);
-    const { data: asset, status } = useEntity('Asset', props.assetId);
+    const { data: asset, status, currentEntity } = useEntity('Asset', props.assetId);
     const { getEntityScheduledActions } = useEntityLoader();
     const loadEntityScheduledActions = React.useCallback(()=>getEntityScheduledActions('Asset', props.assetId), [
         getEntityScheduledActions,
         props.assetId
     ]);
+    const activeLocales = useActiveLocales(props.sdk);
     const localesStatusMap = useLocalePublishStatus(asset, props.sdk.locales);
-    const { releaseLocalesStatusMap } = useActiveReleaseLocalesStatuses({
-        currentEntityDraft: asset,
-        entityId: props.assetId,
-        entityType: 'Asset',
-        releaseVersionMap,
-        locales,
-        activeRelease,
-        releases
+    const { releaseStatusMap, releaseAction } = useReleaseStatus({
+        entity: asset,
+        previousEntityOnTimeline: currentEntity,
+        release: props.sdk.release,
+        locales: props.sdk.locales
     });
-    const { releaseAction } = getEntityReleaseStatus(props.assetId, locales, activeRelease);
-    const activeLocales = useActiveLocales(props.sdk);
     React.useEffect(()=>{
         if (asset) {
             props.onAction && props.onAction({
@@ -89,9 +84,8 @@ export function FetchingWrappedAssetCard(props) {
             useLocalizedEntityStatus: props.sdk.parameters.instance.useLocalizedEntityStatus,
             localesStatusMap,
             activeLocales,
-            releaseLocalesStatusMap,
-            isReleasesLoading: isActiveReleaseLoading,
-            activeRelease,
+            releaseStatusMap,
+            release: props.sdk.release,
             releaseAction
         };
         if (status === 'loading') {

package/dist/esm/assets/WrappedAssetCard/WrappedAssetCard.js

@@ -30,7 +30,7 @@ function getFileType(file) {
     });
     return groupToIconMap[groupName] || 'archive';
 }
-export const WrappedAssetCard = ({ asset, className, size, localeCode, defaultLocaleCode, activeLocales, localesStatusMap, isDisabled, isSelected, isClickable, useLocalizedEntityStatus, renderDragHandle, getEntityScheduledActions, onEdit, getAssetUrl, onRemove, releaseAction, releaseLocalesStatusMap, isReleasesLoading, activeRelease })=>{
+export const WrappedAssetCard = ({ asset, className, size, localeCode, defaultLocaleCode, activeLocales, localesStatusMap, isDisabled, isSelected, isClickable, useLocalizedEntityStatus, renderDragHandle, getEntityScheduledActions, onEdit, getAssetUrl, onRemove, releaseAction, releaseStatusMap, release })=>{
     const status = entityHelpers.getEntityStatus(asset.sys, useLocalizedEntityStatus ? localeCode : undefined);
     if (status === 'deleted') {
         return /*#__PURE__*/ React.createElement(MissingAssetCard, {
@@ -63,9 +63,8 @@ export const WrappedAssetCard = ({ asset, className, size, localeCode, defaultLo
             localesStatusMap: localesStatusMap,
             activeLocales: activeLocales,
             releaseAction: releaseAction,
-            releaseLocalesStatusMap: releaseLocalesStatusMap,
-            isReleasesLoading: isReleasesLoading,
-            activeRelease: activeRelease
+            releaseStatusMap: releaseStatusMap,
+            release: release
         }),
         src: entityFile && entityFile.url ? size === 'small' ? `${entityFile.url}?w=150&h=150&fit=thumb` : `${entityFile.url}?h=300` : '',
         onClick: isClickable ? (e)=>{

package/dist/esm/assets/WrappedAssetCard/WrappedAssetLink.js

@@ -35,9 +35,8 @@ export const WrappedAssetLink = (props)=>{
             localesStatusMap: props.localesStatusMap,
             activeLocales: props.activeLocales,
             releaseAction: props.releaseAction,
-            releaseLocalesStatusMap: props.releaseLocalesStatusMap,
-            isReleasesLoading: props.isReleasesLoading,
-            activeRelease: props.activeRelease
+            releaseStatusMap: props.releaseStatusMap,
+            release: props.release
         }),
         thumbnailElement: entityFile && isValidImage(entityFile) ? /*#__PURE__*/ React.createElement(AssetThumbnail, {
             file: entityFile

package/dist/esm/common/EntityStore.js

@@ -13,7 +13,7 @@ function _define_property(obj, key, value) {
 }
 import React, { useCallback, useEffect, useMemo, useRef } from 'react';
 import constate from 'constate';
-import { createClient, fetchAll } from 'contentful-management';
+import { fetchAll } from 'contentful-management';
 import PQueue from 'p-queue';
 import { SharedQueryClientProvider, useQuery, useQueryClient } from './queryClient';
 export function isContentfulResourceInfo(info) {
@@ -153,12 +153,20 @@ async function fetchExternalResource({ urn, fetch, options, spaceId, environment
             'resource-types',
             spaceId,
             environmentId
-        ], ({ cmaClient })=>fetchAll(({ query })=>cmaClient.resourceType.getForEnvironment({
+        ], ({ cmaClient })=>{
+            console.log('>> fetch resource types', {
+                spaceId,
+                environmentId
+            });
+            return fetchAll(({ query })=>cmaClient.resourceType.getForEnvironment({
                     spaceId,
                     environmentId,
                     query
-                }), {}))
+                }), {});
+        })
     ]);
+    console.log('>> resource', resource);
+    console.log('>> resourceTypes', resourceTypes);
     const resourceTypeEntity = resourceTypes.find((rt)=>rt.sys.id === resourceType);
     if (!resourceTypeEntity) {
         throw new UnsupportedError('Unsupported resource type');
@@ -177,6 +185,7 @@ async function fetchExternalResource({ urn, fetch, options, spaceId, environment
 const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = constate(function useInitServices(props) {
     const currentSpaceId = props.sdk.ids.space;
     const currentEnvironmentId = props.sdk.ids.environmentAlias ?? props.sdk.ids.environment;
+    const releaseId = props.sdk.ids.release;
     const environmentIds = useMemo(()=>[
             props.sdk.ids.environmentAlias,
             props.sdk.ids.environment
@@ -187,13 +196,7 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
     const queryClient = useQueryClient();
     const queryCache = queryClient.getQueryCache();
     const entityChangeUnsubscribers = useRef({});
-    const cmaClient = useMemo(()=>createClient({
-            apiAdapter: props.sdk.cmaAdapter
-        }, {
-            type: 'plain'
-        }), [
-        props.sdk.cmaAdapter
-    ]);
+    const cmaClient = props.sdk.cma;
     const queryQueue = useMemo(()=>{
         if (props.queryConcurrency) {
             return new PQueue({
@@ -216,38 +219,92 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
         queryQueue,
         cmaClient
     ]);
-    const getEntity = useCallback(function getEntity(entityType, entityId, options) {
+    const isReleaseRequestError = useCallback(function isReleaseRequestError(error, spaceId, environmentId) {
+        return !!releaseId && (!spaceId || spaceId === currentSpaceId) && (!environmentId || environmentId === currentEnvironmentId) && error instanceof Error && 'status' in error && error.status === 404;
+    }, [
+        releaseId,
+        currentSpaceId,
+        currentEnvironmentId
+    ]);
+    const getEntity = useCallback(function getEntity(entityType, entityId, releaseId, options) {
         const spaceId = options?.spaceId ?? currentSpaceId;
         const environmentId = options?.environmentId ?? currentEnvironmentId;
         const queryKey = [
             entityType,
             entityId,
             spaceId,
-            environmentId
+            environmentId,
+            releaseId
         ];
-        return fetch(queryKey, ({ cmaClient })=>{
+        return fetch(queryKey, async ({ cmaClient })=>{
             if (entityType === 'Entry') {
-                return cmaClient.entry.get({
-                    entryId: entityId,
-                    spaceId,
-                    environmentId
-                });
+                try {
+                    return cmaClient.entry.get({
+                        entryId: entityId,
+                        spaceId,
+                        environmentId,
+                        releaseId
+                    });
+                } catch (error) {
+                    if (isReleaseRequestError(error, spaceId, environmentId)) {
+                        const currentEntry = await cmaClient.entry.get({
+                            entryId: entityId,
+                            spaceId,
+                            environmentId,
+                            releaseId: undefined
+                        });
+                        currentEntry.sys.release = {
+                            sys: {
+                                type: 'Link',
+                                linkType: 'Release',
+                                id: releaseId
+                            }
+                        };
+                        return currentEntry;
+                    }
+                    throw error;
+                }
             }
             if (entityType === 'Asset') {
-                return cmaClient.asset.get({
-                    assetId: entityId,
-                    spaceId,
-                    environmentId
-                });
+                try {
+                    return cmaClient.asset.get({
+                        assetId: entityId,
+                        spaceId,
+                        environmentId,
+                        releaseId
+                    });
+                } catch (error) {
+                    if (isReleaseRequestError(error, spaceId, environmentId)) {
+                        const currentAsset = cmaClient.asset.get({
+                            assetId: entityId,
+                            spaceId,
+                            environmentId,
+                            releaseId: undefined
+                        });
+                        currentAsset.sys.release = {
+                            sys: {
+                                type: 'Link',
+                                linkType: 'Release',
+                                id: releaseId
+                            }
+                        };
+                        return currentAsset;
+                    }
+                    throw error;
+                }
             }
             throw new UnsupportedError('Unsupported entity type');
         }, options);
     }, [
         fetch,
         currentSpaceId,
-        currentEnvironmentId
+        currentEnvironmentId,
+        isReleaseRequestError
     ]);
     const getEntityScheduledActions = useCallback(function getEntityScheduledActions(entityType, entityId, options) {
+        if (releaseId) {
+            return new Promise((resolve)=>resolve([]));
+        }
         const fixedEntityCacheId = 'scheduledActionEntityId';
         const maxScheduledActions = 500;
         const spaceId = options?.spaceId ?? currentSpaceId;
@@ -257,7 +314,8 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
             entityType,
             fixedEntityCacheId,
             spaceId,
-            environmentId
+            environmentId,
+            releaseId
         ];
         return fetch(queryKey, async ({ cmaClient })=>{
             const response = await cmaClient.scheduledActions.getMany({
@@ -274,7 +332,8 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
     }, [
         fetch,
         currentSpaceId,
-        currentEnvironmentId
+        currentEnvironmentId,
+        releaseId
     ]);
     const getResource = useCallback(function getResource(resourceType, urn, options) {
         const queryKey = [
@@ -402,23 +461,34 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
         getResourceProvider
     }), ({ ids })=>({
         environment: ids.environmentAlias ?? ids.environment,
-        space: ids.space
+        space: ids.space,
+        releaseId: ids.release
     }));
 export function useEntity(entityType, entityId, options) {
-    const { space, environment } = useCurrentIds();
+    const { space, environment, releaseId } = useCurrentIds();
     const { getEntity } = useEntityLoader();
-    const queryKey = [
+    const { status, data } = useQuery([
         entityType,
         entityId,
         options?.spaceId ?? space,
-        options?.environmentId ?? environment
-    ];
-    const { status, data } = useQuery(queryKey, ()=>getEntity(entityType, entityId, options), {
+        options?.environmentId ?? environment,
+        releaseId
+    ], ()=>getEntity(entityType, entityId, releaseId, options), {
         enabled: options?.enabled
     });
+    const { data: currentEntity } = useQuery([
+        entityType,
+        entityId,
+        options?.spaceId ?? space,
+        options?.environmentId ?? environment,
+        undefined
+    ], ()=>getEntity(entityType, entityId, undefined, options), {
+        enabled: options?.enabled && !!releaseId
+    });
     return {
         status,
-        data
+        data,
+        currentEntity
     };
 }
 export function useResource(resourceType, urn, { locale, ...options } = {}) {

package/dist/esm/components/EntityStatusBadge/EntityStatusBadge.js

@@ -3,20 +3,19 @@ import { EntityStatusBadge as StatusBadge } from '@contentful/f36-components';
 import { LocalePublishingPopover, ReleaseEntityStatusPopover, ReleaseEntityStatusBadge } from '@contentful/field-editor-shared';
 import { useScheduledActions } from '../ScheduledIconWithTooltip/ScheduledIconWithTooltip';
 import { ScheduleTooltip } from '../ScheduledIconWithTooltip/ScheduleTooltip';
-export function EntityStatusBadge({ entityType, getEntityScheduledActions, status, useLocalizedEntityStatus, localesStatusMap, activeLocales, entity, releaseLocalesStatusMap, isReleasesLoading, releaseAction, activeRelease, ...props }) {
+export function EntityStatusBadge({ entityType, getEntityScheduledActions, status, useLocalizedEntityStatus, localesStatusMap, activeLocales, entity, releaseStatusMap, releaseAction, release, ...props }) {
     const { isError, isLoading, jobs } = useScheduledActions({
         entityId: entity.sys.id,
         entityType,
         getEntityScheduledActions
     });
-    if (activeRelease && releaseLocalesStatusMap && useLocalizedEntityStatus && activeLocales) {
+    if (release && releaseStatusMap && useLocalizedEntityStatus && activeLocales) {
         return /*#__PURE__*/ React.createElement(ReleaseEntityStatusPopover, {
-            releaseLocalesStatusMap: releaseLocalesStatusMap,
-            activeLocales: activeLocales,
-            isLoading: isReleasesLoading
+            releaseStatusMap: releaseStatusMap,
+            activeLocales: activeLocales
         });
     }
-    if (activeRelease && releaseAction) {
+    if (release && releaseAction) {
         return /*#__PURE__*/ React.createElement(ReleaseEntityStatusBadge, {
             action: releaseAction
         });

package/dist/esm/components/LinkActions/CombinedLinkActions.js

@@ -33,12 +33,12 @@ function CombinedEntryLinkActions(props) {
             onSelect: (contentTypeId)=>{
                 return contentTypeId ? props.onCreate(contentTypeId) : Promise.resolve();
             },
-            customDropdownItems: props.canLinkEntity ? /*#__PURE__*/ React.createElement(Menu, null, /*#__PURE__*/ React.createElement(Menu.Item, {
+            customDropdownItems: props.canLinkEntity ? /*#__PURE__*/ React.createElement(Menu.Item, {
                 testId: testIds.linkExisting,
                 onClick: ()=>{
                     props.onLinkExisting();
                 }
-            }, "Add existing content")) : undefined
+            }, "Add existing content") : undefined
         });
     } else if (props.canLinkEntity) {
         return /*#__PURE__*/ React.createElement(Button, {

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

@@ -1,7 +1,6 @@
 import * as React from 'react';
 import { EntryCard } from '@contentful/f36-components';
-import { parseReleaseParams, useLocalePublishStatus, useActiveReleaseLocalesStatuses, getEntityReleaseStatus } from '@contentful/field-editor-shared';
-import get from 'lodash/get';
+import { useLocalePublishStatus, useReleaseStatus } from '@contentful/field-editor-shared';
 import { useEntity, useEntityLoader } from '../../common/EntityStore';
 import { MissingEntityCard } from '../../components';
 import { WrappedEntryCard } from './WrappedEntryCard';
@@ -25,24 +24,19 @@ async function openEntry(sdk, entryId, options) {
     return slide;
 }
 export function FetchingWrappedEntryCard(props) {
-    const { releaseVersionMap, locales, activeRelease, releases, isActiveReleaseLoading } = parseReleaseParams(props.sdk.parameters.instance.release);
-    const { data: entry, status } = useEntity('Entry', props.entryId);
+    const { data: entry, status, currentEntity } = useEntity('Entry', props.entryId);
     const { getEntityScheduledActions } = useEntityLoader();
     const loadEntityScheduledActions = React.useCallback(()=>getEntityScheduledActions('Entry', props.entryId), [
         getEntityScheduledActions,
         props.entryId
     ]);
     const localesStatusMap = useLocalePublishStatus(entry, props.sdk.locales);
-    const { releaseLocalesStatusMap } = useActiveReleaseLocalesStatuses({
-        currentEntityDraft: entry,
-        entityId: props.entryId,
-        entityType: 'Entry',
-        releaseVersionMap,
-        locales,
-        activeRelease,
-        releases
+    const { releaseStatusMap, releaseAction } = useReleaseStatus({
+        entity: entry,
+        previousEntityOnTimeline: currentEntity,
+        release: props.sdk.release,
+        locales: props.sdk.locales
     });
-    const { releaseAction } = getEntityReleaseStatus(props.entryId, locales, activeRelease);
     const size = props.viewType === 'link' ? 'small' : 'default';
     const { getEntity } = useEntityLoader();
     const getAsset = (assetId)=>getEntity('Asset', assetId);
@@ -55,7 +49,7 @@ export function FetchingWrappedEntryCard(props) {
             entity: 'Entry',
             type: 'edit',
             id: props.entryId,
-            contentTypeId: get(entry, 'sys.contentType.sys.id'),
+            contentTypeId: entry.sys.contentType.sys.id,
             slide
         });
     };
@@ -65,7 +59,7 @@ export function FetchingWrappedEntryCard(props) {
             entity: 'Entry',
             type: 'delete',
             id: props.entryId,
-            contentTypeId: get(entry, 'sys.contentType.sys.id')
+            contentTypeId: entry.sys.contentType.sys.id
         });
     };
     React.useEffect(()=>{
@@ -120,9 +114,8 @@ export function FetchingWrappedEntryCard(props) {
             useLocalizedEntityStatus: props.sdk.parameters.instance.useLocalizedEntityStatus,
             localesStatusMap,
             activeLocales: props.activeLocales,
-            releaseLocalesStatusMap,
-            isReleasesLoading: isActiveReleaseLoading,
-            activeRelease,
+            releaseStatusMap,
+            release: props.sdk.release,
             releaseAction
         };
         const { hasCardEditActions, hasCardMoveActions, hasCardRemoveActions } = props;

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

@@ -10,7 +10,7 @@ const defaultProps = {
     hasCardMoveActions: true,
     hasCardRemoveActions: true
 };
-export function WrappedEntryCard({ entry, entryUrl, contentType, activeLocales, localeCode, defaultLocaleCode, localesStatusMap, useLocalizedEntityStatus, size, spaceName, isClickable, isDisabled, isSelected, hasCardMoveActions, hasCardEditActions, hasCardRemoveActions, renderDragHandle, getAsset, getEntityScheduledActions, onClick, onEdit, onRemove, onMoveTop, onMoveBottom, releaseAction, releaseLocalesStatusMap, isReleasesLoading, activeRelease }) {
+export function WrappedEntryCard({ entry, entryUrl, contentType, activeLocales, localeCode, defaultLocaleCode, localesStatusMap, useLocalizedEntityStatus, size, spaceName, isClickable, isDisabled, isSelected, hasCardMoveActions, hasCardEditActions, hasCardRemoveActions, renderDragHandle, getAsset, getEntityScheduledActions, onClick, onEdit, onRemove, onMoveTop, onMoveBottom, releaseAction, releaseStatusMap, release }) {
     const [file, setFile] = React.useState(null);
     React.useEffect(()=>{
         let mounted = true;
@@ -78,9 +78,8 @@ export function WrappedEntryCard({ entry, entryUrl, contentType, activeLocales,
             localesStatusMap: localesStatusMap,
             activeLocales: activeLocales,
             releaseAction: releaseAction,
-            releaseLocalesStatusMap: releaseLocalesStatusMap,
-            isReleasesLoading: isReleasesLoading,
-            activeRelease: activeRelease
+            releaseStatusMap: releaseStatusMap,
+            release: release
         }),
         icon: spaceName ? /*#__PURE__*/ React.createElement(SpaceName, {
             spaceName: spaceName,

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

@@ -1,6 +1,5 @@
 import * as React from 'react';
 import '@testing-library/jest-dom';
-import { createFakeCMAAdapter } from '@contentful/field-editor-test-utils';
 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';
@@ -27,11 +26,11 @@ const sdk = {
     locales: {
         default: 'en-US'
     },
-    cmaAdapter: createFakeCMAAdapter({
-        ContentType: {
+    cma: {
+        contentType: {
             get: jest.fn().mockReturnValue(publishedCT)
         },
-        Entry: {
+        entry: {
             get: jest.fn().mockImplementation(({ spaceId, environmentId, entryId })=>{
                 if (spaceId === 'space-id' && environmentId === 'master' && entryId === 'linked-entry-urn') {
                     return Promise.resolve(publishedEntry);
@@ -42,7 +41,7 @@ const sdk = {
                 return Promise.reject(new Error());
             })
         },
-        Locale: {
+        locale: {
             getMany: jest.fn().mockResolvedValue({
                 items: [
                     {
@@ -52,7 +51,7 @@ const sdk = {
                 ]
             })
         },
-        Resource: {
+        resource: {
             getMany: jest.fn().mockImplementation(({ spaceId, environmentId, resourceTypeId, query })=>{
                 if (spaceId === 'space-id' && environmentId === 'environment-id' && resourceTypeId === resolvableExternalResourceType && query['sys.urn[in]'] === resolvableExternalEntityUrn) {
                     return Promise.resolve({
@@ -72,8 +71,12 @@ const sdk = {
                 });
             })
         },
-        ResourceType: {
+        resourceType: {
             getForEnvironment: jest.fn().mockImplementation(({ spaceId, environmentId })=>{
+                console.log('>> getForEnvironment', {
+                    spaceId,
+                    environmentId
+                });
                 if (spaceId === 'space-id' && environmentId === 'environment-id') {
                     return Promise.resolve({
                         items: [
@@ -87,16 +90,16 @@ const sdk = {
                 });
             })
         },
-        ScheduledAction: {
+        scheduledActions: {
             getMany: jest.fn().mockResolvedValue({
                 items: [],
                 total: 0
             })
         },
-        Space: {
+        space: {
             get: jest.fn().mockResolvedValue(space)
         },
-        ResourceProvider: {
+        resourceProvider: {
             get: jest.fn().mockImplementation(()=>{
                 return Promise.resolve({
                     function: {
@@ -107,7 +110,7 @@ const sdk = {
                 });
             })
         }
-    }),
+    },
     space: {
         onEntityChanged: jest.fn()
     },

package/dist/types/assets/WrappedAssetCard/WrappedAssetCard.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { SpaceAPI } from '@contentful/app-sdk';
-import { type LocalePublishStatusMap, type ReleaseAction, type ReleaseLocalesStatusMap, type ReleaseV2Props } from '@contentful/field-editor-shared';
+import { type LocalePublishStatusMap, type ReleaseAction, type ReleaseStatusMap, type ReleaseV2Props } from '@contentful/field-editor-shared';
 import { LocaleProps } from 'contentful-management';
 import { Asset, RenderDragFn } from '../../types';
 export interface WrappedAssetCardProps {
@@ -21,12 +21,11 @@ export interface WrappedAssetCardProps {
     localesStatusMap?: LocalePublishStatusMap;
     activeLocales?: Pick<LocaleProps, 'code'>[];
     releaseAction?: ReleaseAction;
-    releaseLocalesStatusMap?: ReleaseLocalesStatusMap;
-    isReleasesLoading?: boolean;
-    activeRelease?: ReleaseV2Props;
+    releaseStatusMap?: ReleaseStatusMap;
+    release?: ReleaseV2Props;
 }
 export declare const WrappedAssetCard: {
-    ({ asset, className, size, localeCode, defaultLocaleCode, activeLocales, localesStatusMap, isDisabled, isSelected, isClickable, useLocalizedEntityStatus, renderDragHandle, getEntityScheduledActions, onEdit, getAssetUrl, onRemove, releaseAction, releaseLocalesStatusMap, isReleasesLoading, activeRelease, }: WrappedAssetCardProps): React.JSX.Element;
+    ({ asset, className, size, localeCode, defaultLocaleCode, activeLocales, localesStatusMap, isDisabled, isSelected, isClickable, useLocalizedEntityStatus, renderDragHandle, getEntityScheduledActions, onEdit, getAssetUrl, onRemove, releaseAction, releaseStatusMap, release, }: WrappedAssetCardProps): React.JSX.Element;
     defaultProps: {
         isClickable: boolean;
     };

package/dist/types/assets/WrappedAssetCard/WrappedAssetLink.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { type ReleaseAction, type LocalePublishStatusMap, type ReleaseLocalesStatusMap, type ReleaseV2Props, type SpaceAPI } from '@contentful/field-editor-shared';
+import { type ReleaseAction, type LocalePublishStatusMap, type ReleaseStatusMap, type ReleaseV2Props, type SpaceAPI } from '@contentful/field-editor-shared';
 import type { LocaleProps } from 'contentful-management';
 import { Asset, RenderDragFn } from '../../types';
 export interface WrappedAssetLinkProps {
@@ -18,8 +18,7 @@ export interface WrappedAssetLinkProps {
     activeLocales?: Pick<LocaleProps, 'code'>[];
     isClickable?: boolean;
     releaseAction?: ReleaseAction;
-    releaseLocalesStatusMap?: ReleaseLocalesStatusMap;
-    isReleasesLoading?: boolean;
-    activeRelease?: ReleaseV2Props;
+    releaseStatusMap?: ReleaseStatusMap;
+    release?: ReleaseV2Props;
 }
 export declare const WrappedAssetLink: (props: WrappedAssetLinkProps) => React.JSX.Element;

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

@@ -24,6 +24,7 @@ type GetOptions = {
 type GetEntityOptions = GetOptions & {
     spaceId?: string;
     environmentId?: string;
+    releaseId?: string;
 };
 type UseEntityOptions = GetEntityOptions & {
     enabled?: boolean;
@@ -41,15 +42,19 @@ type UseResourceOptions = GetResourceOptions & {
 type UseEntityResult<E> = {
     status: 'idle';
     data: never;
+    currentEntity: never;
 } | {
     status: 'loading';
     data: never;
+    currentEntity: never;
 } | {
     status: 'error';
     data: never;
+    currentEntity: never;
 } | {
     status: 'success';
     data: E;
+    currentEntity?: E;
 };
 type FetchableEntityType = 'Entry' | 'Asset';
 type FetchableEntity = Entry | Asset;
@@ -77,11 +82,11 @@ export declare class FunctionInvocationError extends Error {
 export declare function isFunctionInvocationError(value: unknown): value is FunctionInvocationError;
 declare const useEntityLoader: () => {
     getResource: <R extends Resource = Resource>(resourceType: string, urn: string, options?: GetResourceOptions) => QueryResourceResult<R>;
-    getEntity: <E extends FetchableEntity>(entityType: FetchableEntityType, entityId: string, options?: GetEntityOptions) => QueryEntityResult<E>;
+    getEntity: <E extends FetchableEntity>(entityType: FetchableEntityType, entityId: string, releaseId?: string, options?: GetEntityOptions) => QueryEntityResult<E>;
     getEntityScheduledActions: (entityType: FetchableEntityType, entityId: string, options?: GetEntityOptions) => QueryEntityResult<ScheduledAction[]>;
     getResourceProvider: (organizationId: string, appDefinitionId: string) => QueryEntityResult<ResourceProvider>;
 };
-export declare function useEntity<E extends FetchableEntity>(entityType: FetchableEntityType, entityId: string, options?: UseEntityOptions): UseEntityResult<E>;
+export declare function useEntity<E extends FetchableEntity>(entityType: FetchableEntityType, entityId: string, options?: Omit<UseEntityOptions, 'releaseId'>): UseEntityResult<E>;
 export declare function useResource<R extends Resource = Resource>(resourceType: string, urn: string, { locale, ...options }?: UseResourceOptions): {
     status: "error" | "success" | "loading";
     data: ResourceInfo<R> | undefined;

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

@@ -1,9 +1,9 @@
 import * as React from 'react';
-import { LocalePublishStatusMap, type ReleaseAction, type ReleaseLocalesStatusMap, type ReleaseV2Props } from '@contentful/field-editor-shared';
-import { LocaleProps } from 'contentful-management';
-import { WrappedAssetCardProps } from '../assets/WrappedAssetCard/WrappedAssetCard';
-import { Asset, ContentType, Entry, RenderDragFn } from '../types';
-import { CustomActionProps } from './ReferenceEditor';
+import type { LocalePublishStatusMap, ReleaseAction, ReleaseStatusMap, ReleaseV2Props } from '@contentful/field-editor-shared';
+import type { LocaleProps } from 'contentful-management';
+import type { WrappedAssetCardProps } from '../assets/WrappedAssetCard/WrappedAssetCard';
+import type { Asset, ContentType, Entry, RenderDragFn } from '../types';
+import type { CustomActionProps } from './ReferenceEditor';
 export type MissingEntityCardProps = {
     defaultCard: React.ReactElement;
     entity: {
@@ -32,8 +32,7 @@ export type CustomEntityCardProps = {
     useLocalizedEntityStatus?: boolean;
     localesStatusMap?: LocalePublishStatusMap;
     activeLocales?: Pick<LocaleProps, 'code'>[];
-    releaseLocalesStatusMap?: ReleaseLocalesStatusMap;
-    isReleasesLoading?: boolean;
+    releaseStatusMap?: ReleaseStatusMap;
     releaseAction?: ReleaseAction;
-    activeRelease?: ReleaseV2Props;
+    release?: ReleaseV2Props;
 } & Partial<WrappedAssetCardProps>;