@contentful/field-editor-rich-text 3.12.7 → 3.13.0

package/dist/cjs/plugins/shared/ResourceNewBadge.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ResourceNewBadge", {
+    enumerable: true,
+    get: function() {
+        return ResourceNewBadge;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36components = require("@contentful/f36-components");
+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 ResourceNewBadge = ()=>{
+    return _react.createElement(_react.Fragment, null, ' ', "(different space)", ' ', _react.createElement(_f36components.Badge, {
+        variant: "primary-filled",
+        size: "small"
+    }, "new"));
+};

package/dist/cjs/plugins/shared/__tests__/FetchingWrappedResourceCard.test.js

@@ -10,7 +10,7 @@ const _react1 = require("@testing-library/react");
 const _published_content_typejson = _interop_require_default(require("../__fixtures__/published_content_type.json"));
 const _published_entryjson = _interop_require_default(require("../__fixtures__/published_entry.json"));
 const _spacejson = _interop_require_default(require("../__fixtures__/space.json"));
-const _FetchingWrappedResourceCard = require("../FetchingWrappedResourceCard");
+const _FetchingWrappedResourceBlockCard = require("../../EmbeddedResourceBlock/FetchingWrappedResourceBlockCard");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -111,7 +111,7 @@ beforeEach(()=>{
 function renderResourceCard({ linkType ='Contentful:Entry' , entryUrn =resolvableEntryUrn  } = {}) {
     return (0, _react1.render)(_react.createElement(_fieldeditorreference.EntityProvider, {
         sdk: sdk
-    }, _react.createElement(_FetchingWrappedResourceCard.FetchingWrappedResourceCard, {
+    }, _react.createElement(_FetchingWrappedResourceBlockCard.FetchingWrappedResourceBlockCard, {
         isDisabled: false,
         isSelected: false,
         sdk: sdk,

package/dist/esm/Toolbar/components/EmbedEntityWidget.js

@@ -14,6 +14,7 @@ export const EmbedEntityWidget = ({ isDisabled , canInsertBlocks  })=>{
     const onCloseEntityDropdown = ()=>setEmbedDropdownOpen(false);
     const onToggleEntityDropdown = ()=>setEmbedDropdownOpen(!isEmbedDropdownOpen);
     const inlineEntryEmbedEnabled = isNodeTypeEnabled(sdk.field, INLINES.EMBEDDED_ENTRY);
+    const inlineResourceEmbedEnabled = isNodeTypeEnabled(sdk.field, INLINES.EMBEDDED_RESOURCE);
     const blockEntryEmbedEnabled = isNodeTypeEnabled(sdk.field, BLOCKS.EMBEDDED_ENTRY) && canInsertBlocks;
     const blockResourceEmbedEnabled = isNodeTypeEnabled(sdk.field, BLOCKS.EMBEDDED_RESOURCE) && canInsertBlocks;
     const blockAssetEmbedEnabled = isNodeTypeEnabled(sdk.field, BLOCKS.EMBEDDED_ASSET) && canInsertBlocks;
@@ -26,6 +27,11 @@ export const EmbedEntityWidget = ({ isDisabled , canInsertBlocks  })=>{
         nodeType: BLOCKS.EMBEDDED_RESOURCE,
         onClose: onCloseEntityDropdown
     }), inlineEntryEmbedEnabled && React.createElement(EmbeddedInlineToolbarIcon, {
+        nodeType: INLINES.EMBEDDED_ENTRY,
+        isDisabled: !!isDisabled || isLinkActive(editor),
+        onClose: onCloseEntityDropdown
+    }), inlineResourceEmbedEnabled && React.createElement(EmbeddedInlineToolbarIcon, {
+        nodeType: INLINES.EMBEDDED_RESOURCE,
         isDisabled: !!isDisabled || isLinkActive(editor),
         onClose: onCloseEntityDropdown
     }), blockAssetEmbedEnabled && React.createElement(EmbeddedBlockToolbarIcon, {

package/dist/esm/constants/Schema.js

@@ -157,6 +157,9 @@ export default {
         },
         [INLINES.EMBEDDED_ENTRY]: {
             isVoid: true
+        },
+        [INLINES.EMBEDDED_RESOURCE]: {
+            isVoid: true
         }
     }
 };

package/dist/esm/helpers/{newEntitySelectorConfigFromRichTextField.js → config.js}

@@ -1,11 +1,12 @@
+import getAllowedResourcesForNodeType from './getAllowedResourcesForNodeType';
 import getLinkedContentTypeIdsForNodeType from './getLinkedContentTypeIdsForNodeType';
-export default function newEntitySelectorConfigFromRichTextField(field, nodeType) {
+export const newEntitySelectorConfigFromRichTextField = (field, nodeType)=>{
     return {
         entityType: getEntityTypeFromRichTextNode(nodeType),
         locale: field.locale || null,
         contentTypes: getLinkedContentTypeIdsForNodeType(field, nodeType)
     };
-}
+};
 function getEntityTypeFromRichTextNode(nodeType) {
     const words = nodeType.split('-');
     if (words.indexOf('entry') !== -1) {
@@ -16,3 +17,8 @@ function getEntityTypeFromRichTextNode(nodeType) {
     }
     throw new Error(`RichText node type \`${nodeType}\` has no associated \`entityType\``);
 }
+export const newResourceEntitySelectorConfigFromRichTextField = (field, nodeType)=>{
+    return {
+        allowedResources: getAllowedResourcesForNodeType(field, nodeType)
+    };
+};

package/dist/esm/plugins/DragAndDrop/index.js

@@ -6,11 +6,13 @@ export function createDragAndDropPlugin() {
         BLOCKS.EMBEDDED_ASSET,
         BLOCKS.EMBEDDED_RESOURCE,
         BLOCKS.HR,
-        INLINES.EMBEDDED_ENTRY
+        INLINES.EMBEDDED_ENTRY,
+        INLINES.EMBEDDED_RESOURCE
     ];
     const ON_DROP_ALLOWED_TYPES = {
         TABLE: [
-            INLINES.EMBEDDED_ENTRY
+            INLINES.EMBEDDED_ENTRY,
+            INLINES.EMBEDDED_RESOURCE
         ]
     };
     return {

package/dist/esm/plugins/EmbeddedEntityInline/index.js

@@ -1,11 +1,12 @@
 import { INLINES } from '@contentful/rich-text-types';
-import { createInlineEntryNode, getWithEmbeddedEntryInlineEvents } from '../shared/EmbeddedInlineUtil';
+import { getWithEmbeddedEntryInlineEvents } from '../shared/EmbeddedInlineUtil';
 import { LinkedEntityInline } from './LinkedEntityInline';
 export function createEmbeddedEntityInlinePlugin(sdk) {
     const htmlAttributeName = 'data-embedded-entity-inline-id';
+    const nodeType = INLINES.EMBEDDED_ENTRY;
     return {
-        key: INLINES.EMBEDDED_ENTRY,
-        type: INLINES.EMBEDDED_ENTRY,
+        key: nodeType,
+        type: nodeType,
         isElement: true,
         isInline: true,
         isVoid: true,
@@ -14,7 +15,7 @@ export function createEmbeddedEntityInlinePlugin(sdk) {
             hotkey: 'mod+shift+2'
         },
         handlers: {
-            onKeyDown: getWithEmbeddedEntryInlineEvents(sdk)
+            onKeyDown: getWithEmbeddedEntryInlineEvents(nodeType, sdk)
         },
         deserializeHtml: {
             rules: [
@@ -23,7 +24,23 @@ export function createEmbeddedEntityInlinePlugin(sdk) {
                 }
             ],
             withoutChildren: true,
-            getNode: (el)=>createInlineEntryNode(el.getAttribute(htmlAttributeName))
+            getNode: (el)=>({
+                    type: nodeType,
+                    children: [
+                        {
+                            text: ''
+                        }
+                    ],
+                    data: {
+                        target: {
+                            sys: {
+                                id: el.getAttribute('data-entity-id'),
+                                type: 'Link',
+                                linkType: el.getAttribute('data-entity-type')
+                            }
+                        }
+                    }
+                })
         }
     };
 }

package/dist/esm/plugins/{shared/FetchingWrappedResourceCard.js → EmbeddedResourceBlock/FetchingWrappedResourceBlockCard.js}

@@ -26,7 +26,7 @@ const InternalEntryCard = React.memo((props)=>{
     });
 }, areEqual);
 InternalEntryCard.displayName = 'ReferenceCard';
-export const FetchingWrappedResourceCard = (props)=>{
+export const FetchingWrappedResourceBlockCard = (props)=>{
     const { link , onEntityFetchComplete  } = props;
     const { data , status , error  } = useResource(link.linkType, link.urn);
     React.useEffect(()=>{

package/dist/esm/plugins/EmbeddedResourceBlock/LinkedResourceBlock.js

@@ -4,8 +4,8 @@ import { useContentfulEditor } from '../../ContentfulEditorProvider';
 import { findNodePath, removeNodes } from '../../internal';
 import { useSdkContext } from '../../SdkProvider';
 import { useLinkTracking } from '../links-tracking';
-import { FetchingWrappedResourceCard } from '../shared/FetchingWrappedResourceCard';
 import { LinkedBlockWrapper } from '../shared/LinkedBlockWrapper';
+import { FetchingWrappedResourceBlockCard } from './FetchingWrappedResourceBlockCard';
 export function LinkedResourceBlock(props) {
     const { attributes , children , element  } = props;
     const { onEntityFetchComplete  } = useLinkTracking();
@@ -27,7 +27,7 @@ export function LinkedResourceBlock(props) {
     return React.createElement(LinkedBlockWrapper, {
         attributes: attributes,
         link: element.data.target,
-        card: React.createElement(FetchingWrappedResourceCard, {
+        card: React.createElement(FetchingWrappedResourceBlockCard, {
             sdk: sdk,
             link: link,
             isDisabled: isDisabled,

package/dist/esm/plugins/EmbeddedResourceInline/FetchingWrappedResourceInlineCard.js

@@ -0,0 +1,53 @@
+import * as React from 'react';
+import { InlineEntryCard, MenuItem, Text } from '@contentful/f36-components';
+import { useResource } from '@contentful/field-editor-reference';
+import { entityHelpers } from '@contentful/field-editor-shared';
+import { INLINES } from '@contentful/rich-text-types';
+const { getEntryTitle , getEntryStatus  } = entityHelpers;
+export function FetchingWrappedResourceInlineCard(props) {
+    const { link , onEntityFetchComplete  } = props;
+    const { data , status: requestStatus  } = useResource(link.linkType, link.urn);
+    React.useEffect(()=>{
+        if (requestStatus === 'success') {
+            onEntityFetchComplete?.();
+        }
+    }, [
+        onEntityFetchComplete,
+        requestStatus
+    ]);
+    if (requestStatus === 'error') {
+        return React.createElement(InlineEntryCard, {
+            title: "Entry missing or inaccessible",
+            testId: INLINES.EMBEDDED_RESOURCE,
+            isSelected: props.isSelected
+        });
+    }
+    if (requestStatus === 'loading' || data === undefined) {
+        return React.createElement(InlineEntryCard, {
+            isLoading: true
+        });
+    }
+    const { resource: entry , contentType , defaultLocaleCode , space  } = data;
+    const title = getEntryTitle({
+        entry,
+        contentType,
+        defaultLocaleCode,
+        localeCode: defaultLocaleCode,
+        defaultTitle: 'Untitled'
+    });
+    const status = getEntryStatus(entry?.sys);
+    return React.createElement(InlineEntryCard, {
+        testId: INLINES.EMBEDDED_RESOURCE,
+        isSelected: props.isSelected,
+        title: `${data.contentType.name}: ${title} (Space: ${space.name})`,
+        status: status,
+        actions: [
+            React.createElement(MenuItem, {
+                key: "remove",
+                onClick: props.onRemove,
+                disabled: props.isDisabled,
+                testId: "delete"
+            }, "Remove")
+        ]
+    }, React.createElement(Text, null, title));
+}

package/dist/esm/plugins/EmbeddedResourceInline/LinkedResourceInline.js

@@ -0,0 +1,36 @@
+import React from 'react';
+import { useSelected, useReadOnly } from 'slate-react';
+import { useContentfulEditor } from '../../ContentfulEditorProvider';
+import { findNodePath, removeNodes } from '../../internal';
+import { useSdkContext } from '../../SdkProvider';
+import { useLinkTracking } from '../links-tracking';
+import { LinkedInlineWrapper } from '../shared/LinkedInlineWrapper';
+import { FetchingWrappedResourceInlineCard } from './FetchingWrappedResourceInlineCard';
+export function LinkedResourceInline(props) {
+    const { attributes , children , element  } = props;
+    const { onEntityFetchComplete  } = useLinkTracking();
+    const isSelected = useSelected();
+    const editor = useContentfulEditor();
+    const sdk = useSdkContext();
+    const isDisabled = useReadOnly();
+    const link = element.data.target.sys;
+    function handleRemoveClick() {
+        if (!editor) return;
+        const pathToElement = findNodePath(editor, element);
+        removeNodes(editor, {
+            at: pathToElement
+        });
+    }
+    return React.createElement(LinkedInlineWrapper, {
+        attributes: attributes,
+        link: element.data.target,
+        card: React.createElement(FetchingWrappedResourceInlineCard, {
+            sdk: sdk,
+            link: link,
+            isDisabled: isDisabled,
+            isSelected: isSelected,
+            onRemove: handleRemoveClick,
+            onEntityFetchComplete: onEntityFetchComplete
+        })
+    }, children);
+}

package/dist/esm/plugins/EmbeddedResourceInline/index.js

@@ -0,0 +1,46 @@
+import { INLINES } from '@contentful/rich-text-types';
+import { getWithEmbeddedEntryInlineEvents } from '../shared/EmbeddedInlineUtil';
+import { LinkedResourceInline } from './LinkedResourceInline';
+export function createEmbeddedResourceInlinePlugin(sdk) {
+    const htmlAttributeName = 'data-embedded-resource-inline-id';
+    const nodeType = INLINES.EMBEDDED_RESOURCE;
+    return {
+        key: nodeType,
+        type: nodeType,
+        isElement: true,
+        isInline: true,
+        isVoid: true,
+        component: LinkedResourceInline,
+        options: {
+            hotkey: 'mod+shift+p'
+        },
+        handlers: {
+            onKeyDown: getWithEmbeddedEntryInlineEvents(nodeType, sdk)
+        },
+        deserializeHtml: {
+            rules: [
+                {
+                    validAttribute: htmlAttributeName
+                }
+            ],
+            withoutChildren: true,
+            getNode: (el)=>({
+                    type: nodeType,
+                    children: [
+                        {
+                            text: ''
+                        }
+                    ],
+                    data: {
+                        target: {
+                            sys: {
+                                urn: el.getAttribute('data-entity-id'),
+                                linkType: el.getAttribute('data-entity-type'),
+                                type: 'ResourceLink'
+                            }
+                        }
+                    }
+                })
+        }
+    };
+}

package/dist/esm/plugins/index.js

@@ -6,6 +6,7 @@ import { createDragAndDropPlugin } from './DragAndDrop';
 import { createEmbeddedAssetBlockPlugin, createEmbeddedEntryBlockPlugin } from './EmbeddedEntityBlock';
 import { createEmbeddedEntityInlinePlugin } from './EmbeddedEntityInline';
 import { createEmbeddedResourceBlockPlugin } from './EmbeddedResourceBlock';
+import { createEmbeddedResourceInlinePlugin } from './EmbeddedResourceInline';
 import { createHeadingPlugin } from './Heading';
 import { createHrPlugin } from './Hr';
 import { createHyperlinkPlugin } from './Hyperlink';
@@ -39,6 +40,7 @@ export const getPlugins = (sdk, onAction, restrictedMarks)=>[
         createEmbeddedResourceBlockPlugin(sdk),
         createHyperlinkPlugin(sdk),
         createEmbeddedEntityInlinePlugin(sdk),
+        createEmbeddedResourceInlinePlugin(sdk),
         createMarksPlugin(),
         createTrailingParagraphPlugin(),
         createTextPlugin(restrictedMarks),

package/dist/esm/plugins/shared/EmbeddedBlockToolbarIcon.js

@@ -1,11 +1,12 @@
 import * as React from 'react';
-import { Badge, Flex, Icon, Menu } from '@contentful/f36-components';
+import { Flex, Icon, Menu } from '@contentful/f36-components';
 import { AssetIcon, EmbeddedEntryBlockIcon } from '@contentful/f36-icons';
 import { BLOCKS } from '@contentful/rich-text-types';
 import { css } from 'emotion';
 import { useContentfulEditor } from '../../ContentfulEditorProvider';
 import { useSdkContext } from '../../SdkProvider';
 import { selectEntityAndInsert, selectResourceEntityAndInsert } from '../shared/EmbeddedBlockUtil';
+import { ResourceNewBadge } from './ResourceNewBadge';
 export const styles = {
     icon: css({
         marginRight: '10px'
@@ -40,10 +41,7 @@ export function EmbeddedBlockToolbarIcon({ isDisabled , nodeType , onClose  }) {
         as: type === 'Asset' ? AssetIcon : EmbeddedEntryBlockIcon,
         className: `rich-text__embedded-entry-list-icon ${styles.icon}`,
         variant: "secondary"
-    }), React.createElement("span", null, type, nodeType == BLOCKS.EMBEDDED_RESOURCE && React.createElement(React.Fragment, null, ' ', "(different space)", ' ', React.createElement(Badge, {
-        variant: "primary-filled",
-        size: "small"
-    }, "new")))));
+    }), React.createElement("span", null, type, nodeType == BLOCKS.EMBEDDED_RESOURCE && React.createElement(ResourceNewBadge, null))));
 }
 function getEntityTypeFromNodeType(nodeType) {
     const words = nodeType.toLowerCase().split('-');

package/dist/esm/plugins/shared/EmbeddedBlockUtil.js

@@ -1,8 +1,7 @@
 import { BLOCKS, TEXT_CONTAINERS } from '@contentful/rich-text-types';
 import isHotkey from 'is-hotkey';
+import { newEntitySelectorConfigFromRichTextField, newResourceEntitySelectorConfigFromRichTextField } from '../../helpers/config';
 import { focus, getNodeEntryFromSelection, insertEmptyParagraph, moveToTheNextChar } from '../../helpers/editor';
-import newEntitySelectorConfigFromRichTextField from '../../helpers/newEntitySelectorConfigFromRichTextField';
-import newResourceEntitySelectorConfigFromRichTextField from '../../helpers/newResourceEntitySelectorConfigFromRichTextField';
 import { watchCurrentSlide } from '../../helpers/sdkNavigatorSlideIn';
 import { getText, getAboveNode, getLastNodeByLevel, insertNodes, setNodes, select, removeNodes } from '../../internal';
 export function getWithEmbeddedBlockEvents(nodeType, sdk) {

package/dist/esm/plugins/shared/EmbeddedInlineToolbarIcon.js

@@ -7,7 +7,8 @@ import { css } from 'emotion';
 import { useContentfulEditor } from '../../ContentfulEditorProvider';
 import { moveToTheNextChar } from '../../helpers/editor';
 import { useSdkContext } from '../../SdkProvider';
-import { selectEntityAndInsert } from '../shared/EmbeddedInlineUtil';
+import { selectEntityAndInsert, selectResourceEntityAndInsert } from '../shared/EmbeddedInlineUtil';
+import { ResourceNewBadge } from './ResourceNewBadge';
 const styles = {
     icon: css({
         marginRight: '10px'
@@ -21,20 +22,24 @@ const styles = {
         }
     })
 };
-export function EmbeddedInlineToolbarIcon(props) {
+export function EmbeddedInlineToolbarIcon({ onClose , nodeType , isDisabled  }) {
     const editor = useContentfulEditor();
     const sdk = useSdkContext();
     async function handleClick(event) {
         event.preventDefault();
         if (!editor) return;
-        props.onClose();
-        await selectEntityAndInsert(editor, sdk, editor.tracking.onToolbarAction);
+        onClose();
+        if (nodeType === INLINES.EMBEDDED_RESOURCE) {
+            await selectResourceEntityAndInsert(editor, sdk, editor.tracking.onToolbarAction);
+        } else {
+            await selectEntityAndInsert(editor, sdk, editor.tracking.onToolbarAction);
+        }
         moveToTheNextChar(editor);
     }
     return React.createElement(Menu.Item, {
-        disabled: props.isDisabled,
+        disabled: isDisabled,
         className: "rich-text__entry-link-block-button",
-        testId: `toolbar-toggle-${INLINES.EMBEDDED_ENTRY}`,
+        testId: `toolbar-toggle-${nodeType}`,
         onClick: handleClick
     }, React.createElement(Flex, {
         alignItems: "center",
@@ -42,5 +47,5 @@ export function EmbeddedInlineToolbarIcon(props) {
     }, React.createElement(EmbeddedEntryInlineIcon, {
         variant: "secondary",
         className: `rich-text__embedded-entry-list-icon ${styles.icon}`
-    }), React.createElement("span", null, "Inline entry")));
+    }), React.createElement("span", null, "Inline entry", nodeType == INLINES.EMBEDDED_RESOURCE && React.createElement(ResourceNewBadge, null))));
 }

package/dist/esm/plugins/shared/EmbeddedInlineUtil.js

@@ -1,25 +1,59 @@
 import { INLINES } from '@contentful/rich-text-types';
 import isHotkey from 'is-hotkey';
+import { newEntitySelectorConfigFromRichTextField, newResourceEntitySelectorConfigFromRichTextField } from '../../helpers/config';
 import { focus } from '../../helpers/editor';
-import newEntitySelectorConfigFromRichTextField from '../../helpers/newEntitySelectorConfigFromRichTextField';
 import { watchCurrentSlide } from '../../helpers/sdkNavigatorSlideIn';
 import { insertNodes, select } from '../../internal/transforms';
-export function getWithEmbeddedEntryInlineEvents(sdk) {
+export function getWithEmbeddedEntryInlineEvents(nodeType, sdk) {
     return function withEmbeddedEntryInlineEvents(editor, { options: { hotkey  }  }) {
         return function handleEvent(event) {
             if (!editor) return;
             if (hotkey && isHotkey(hotkey, event)) {
-                selectEntityAndInsert(editor, sdk, editor.tracking.onShortcutAction);
+                if (nodeType === INLINES.EMBEDDED_RESOURCE) {
+                    selectResourceEntityAndInsert(editor, sdk, editor.tracking.onShortcutAction);
+                } else {
+                    selectEntityAndInsert(editor, sdk, editor.tracking.onShortcutAction);
+                }
             }
         };
     };
 }
+const getLink = (nodeType, entity)=>{
+    if (nodeType === INLINES.EMBEDDED_RESOURCE) {
+        return {
+            urn: entity.sys.urn,
+            type: 'ResourceLink',
+            linkType: 'Contentful:Entry'
+        };
+    }
+    return {
+        id: entity.sys.id,
+        type: 'Link',
+        linkType: entity.sys.type
+    };
+};
+const createInlineEntryNode = (nodeType, entity)=>{
+    return {
+        type: nodeType,
+        children: [
+            {
+                text: ''
+            }
+        ],
+        data: {
+            target: {
+                sys: getLink(nodeType, entity)
+            }
+        }
+    };
+};
 export async function selectEntityAndInsert(editor, sdk, logAction) {
+    const nodeType = INLINES.EMBEDDED_ENTRY;
     logAction('openCreateEmbedDialog', {
-        nodeType: INLINES.EMBEDDED_ENTRY
+        nodeType
     });
     const config = {
-        ...newEntitySelectorConfigFromRichTextField(sdk.field, INLINES.EMBEDDED_ENTRY),
+        ...newEntitySelectorConfigFromRichTextField(sdk.field, nodeType),
         withCreate: true
     };
     const { selection  } = editor;
@@ -27,13 +61,13 @@ export async function selectEntityAndInsert(editor, sdk, logAction) {
     const entry = await sdk.dialogs.selectSingleEntry(config);
     if (!entry) {
         logAction('cancelCreateEmbedDialog', {
-            nodeType: INLINES.EMBEDDED_ENTRY
+            nodeType
         });
     } else {
         select(editor, selection);
-        insertNodes(editor, createInlineEntryNode(entry.sys.id));
+        insertNodes(editor, createInlineEntryNode(nodeType, entry));
         logAction('insert', {
-            nodeType: INLINES.EMBEDDED_ENTRY
+            nodeType
         });
     }
     rteSlide.onActive(()=>{
@@ -41,22 +75,27 @@ export async function selectEntityAndInsert(editor, sdk, logAction) {
         focus(editor);
     });
 }
-export function createInlineEntryNode(id) {
-    return {
-        type: INLINES.EMBEDDED_ENTRY,
-        children: [
-            {
-                text: ''
-            }
-        ],
-        data: {
-            target: {
-                sys: {
-                    id,
-                    type: 'Link',
-                    linkType: 'Entry'
-                }
-            }
-        }
+export async function selectResourceEntityAndInsert(editor, sdk, logAction) {
+    const nodeType = INLINES.EMBEDDED_RESOURCE;
+    logAction('openCreateEmbedDialog', {
+        nodeType
+    });
+    const { dialogs , field  } = sdk;
+    const config = {
+        ...newResourceEntitySelectorConfigFromRichTextField(field, nodeType),
+        withCreate: true
     };
+    const { selection  } = editor;
+    const entry = await dialogs.selectSingleResourceEntry(config);
+    if (!entry) {
+        logAction('cancelCreateEmbedDialog', {
+            nodeType
+        });
+    } else {
+        select(editor, selection);
+        insertNodes(editor, createInlineEntryNode(nodeType, entry));
+        logAction('insert', {
+            nodeType
+        });
+    }
 }

package/dist/esm/plugins/shared/ResourceNewBadge.js

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { Badge } from '@contentful/f36-components';
+export const ResourceNewBadge = ()=>{
+    return React.createElement(React.Fragment, null, ' ', "(different space)", ' ', React.createElement(Badge, {
+        variant: "primary-filled",
+        size: "small"
+    }, "new"));
+};

package/dist/esm/plugins/shared/__tests__/FetchingWrappedResourceCard.test.js

@@ -6,7 +6,7 @@ import { configure, render, waitFor } from '@testing-library/react';
 import publishedCT from '../__fixtures__/published_content_type.json';
 import publishedEntry from '../__fixtures__/published_entry.json';
 import space from '../__fixtures__/space.json';
-import { FetchingWrappedResourceCard } from '../FetchingWrappedResourceCard';
+import { FetchingWrappedResourceBlockCard } from '../../EmbeddedResourceBlock/FetchingWrappedResourceBlockCard';
 configure({
     testIdAttribute: 'data-test-id'
 });
@@ -63,7 +63,7 @@ beforeEach(()=>{
 function renderResourceCard({ linkType ='Contentful:Entry' , entryUrn =resolvableEntryUrn  } = {}) {
     return render(React.createElement(EntityProvider, {
         sdk: sdk
-    }, React.createElement(FetchingWrappedResourceCard, {
+    }, React.createElement(FetchingWrappedResourceBlockCard, {
         isDisabled: false,
         isSelected: false,
         sdk: sdk,

package/dist/types/constants/Schema.d.ts

@@ -106,6 +106,9 @@ declare const _default: {
         "embedded-entry-inline": {
             isVoid: boolean;
         };
+        "embedded-resource-inline": {
+            isVoid: boolean;
+        };
     };
 };
 export default _default;