@contentful/field-editor-rich-text 3.5.0 → 3.6.1

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

@@ -1,45 +1,21 @@
 import { BLOCKS } from '@contentful/rich-text-types';
-import isHotkey from 'is-hotkey';
-import { getNodeEntryFromSelection } from '../../helpers/editor';
-import { removeNodes } from '../../internal/transforms';
-import { withLinkTracking } from '../links-tracking';
+import { getWithEmbeddedBlockEvents } from '../shared/EmbeddedBlockUtil';
 import { LinkedEntityBlock } from './LinkedEntityBlock';
-import { selectEntityAndInsert } from './Util';
-export { EmbeddedEntityBlockToolbarIcon as ToolbarIcon } from './ToolbarIcon';
 const entityTypes = {
     [BLOCKS.EMBEDDED_ENTRY]: 'Entry',
     [BLOCKS.EMBEDDED_ASSET]: 'Asset'
 };
-function getWithEmbeddedEntityEvents(nodeType, sdk) {
-    return (editor, { options: { hotkey  }  })=>(event)=>{
-            const [, pathToSelectedElement] = getNodeEntryFromSelection(editor, nodeType);
-            if (pathToSelectedElement) {
-                const isDelete = event.key === 'Delete';
-                const isBackspace = event.key === 'Backspace';
-                if (isDelete || isBackspace) {
-                    event.preventDefault();
-                    removeNodes(editor, {
-                        at: pathToSelectedElement
-                    });
-                }
-                return;
-            }
-            if (hotkey && isHotkey(hotkey, event)) {
-                selectEntityAndInsert(nodeType, sdk, editor, editor.tracking.onShortcutAction);
-            }
-        };
-}
 const createEmbeddedEntityPlugin = (nodeType, hotkey)=>(sdk)=>({
             key: nodeType,
             type: nodeType,
             isElement: true,
             isVoid: true,
-            component: withLinkTracking(LinkedEntityBlock),
+            component: LinkedEntityBlock,
             options: {
                 hotkey
             },
             handlers: {
-                onKeyDown: getWithEmbeddedEntityEvents(nodeType, sdk)
+                onKeyDown: getWithEmbeddedBlockEvents(nodeType, sdk)
             },
             deserializeHtml: {
                 rules: [

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

@@ -14,7 +14,7 @@ import { watchCurrentSlide } from '../../helpers/sdkNavigatorSlideIn';
 import { findNodePath } from '../../internal/queries';
 import { insertNodes, removeNodes, select } from '../../internal/transforms';
 import { useSdkContext } from '../../SdkProvider';
-import { withLinkTracking } from '../links-tracking';
+import { useLinkTracking } from '../links-tracking';
 import { FetchingWrappedInlineEntryCard } from './FetchingWrappedInlineEntryCard';
 import { createInlineEntryNode } from './Util';
 const styles = {
@@ -36,6 +36,7 @@ function EmbeddedEntityInline(props) {
     const isSelected = useSelected();
     const { id: entryId  } = props.element.data.target.sys;
     const isDisabled = useReadOnly();
+    const { onEntityFetchComplete  } = useLinkTracking();
     function handleEditClick() {
         return sdk.navigator.openEntry(entryId, {
             slideIn: {
@@ -68,7 +69,7 @@ function EmbeddedEntityInline(props) {
         isDisabled: isDisabled,
         onRemove: handleRemoveClick,
         onEdit: handleEditClick,
-        onEntityFetchComplete: props.onEntityFetchComplete
+        onEntityFetchComplete: onEntityFetchComplete
     })), props.children);
 }
 async function selectEntityAndInsert(editor, sdk, logAction) {
@@ -129,7 +130,7 @@ export function createEmbeddedEntityInlinePlugin(sdk) {
         isElement: true,
         isInline: true,
         isVoid: true,
-        component: withLinkTracking(EmbeddedEntityInline),
+        component: EmbeddedEntityInline,
         options: {
             hotkey: 'mod+shift+2'
         },

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

@@ -0,0 +1,39 @@
+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 { FetchingWrappedResourceCard } from '../shared/FetchingWrappedResourceCard';
+import { LinkedBlockWrapper } from '../shared/LinkedBlockWrapper';
+export function LinkedResourceBlock(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;
+    const handleRemoveClick = React.useCallback(()=>{
+        if (!editor) return;
+        const pathToElement = findNodePath(editor, element);
+        removeNodes(editor, {
+            at: pathToElement
+        });
+    }, [
+        editor,
+        element
+    ]);
+    return React.createElement(LinkedBlockWrapper, {
+        attributes: attributes,
+        element: element,
+        card: React.createElement(FetchingWrappedResourceCard, {
+            sdk: sdk,
+            link: link,
+            isDisabled: isDisabled,
+            isSelected: isSelected,
+            onRemove: handleRemoveClick,
+            onEntityFetchComplete: onEntityFetchComplete
+        })
+    }, children);
+}

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

@@ -0,0 +1,45 @@
+import { BLOCKS } from '@contentful/rich-text-types';
+import { getWithEmbeddedBlockEvents } from '../shared/EmbeddedBlockUtil';
+import { LinkedResourceBlock } from './LinkedResourceBlock';
+const createEmbeddedResourcePlugin = (nodeType, hotkey)=>(sdk)=>({
+            key: nodeType,
+            type: nodeType,
+            isElement: true,
+            isVoid: true,
+            component: LinkedResourceBlock,
+            options: {
+                hotkey
+            },
+            handlers: {
+                onKeyDown: getWithEmbeddedBlockEvents(nodeType, sdk)
+            },
+            deserializeHtml: {
+                rules: [
+                    {
+                        validAttribute: {
+                            'data-entity-type': 'Contentful:Entry'
+                        }
+                    }
+                ],
+                withoutChildren: true,
+                getNode: (el)=>({
+                        type: nodeType,
+                        children: [
+                            {
+                                text: ''
+                            }
+                        ],
+                        isVoid: true,
+                        data: {
+                            target: {
+                                sys: {
+                                    urn: el.getAttribute('data-entity-id'),
+                                    linkType: el.getAttribute('data-entity-type'),
+                                    type: 'ResourceLink'
+                                }
+                            }
+                        }
+                    })
+            }
+        });
+export const createEmbeddedResourceBlockPlugin = createEmbeddedResourcePlugin(BLOCKS.EMBEDDED_RESOURCE, 'mod+shift+s');

package/dist/esm/plugins/Hyperlink/components/EntityHyperlink.js

@@ -3,6 +3,7 @@ import { Tooltip, TextLink } from '@contentful/f36-components';
 import { useContentfulEditor } from '../../../ContentfulEditorProvider';
 import { fromDOMPoint } from '../../../internal';
 import { useSdkContext } from '../../../SdkProvider';
+import { useLinkTracking } from '../../links-tracking';
 import { addOrEditLink } from '../HyperlinkModal';
 import { useEntityInfo } from '../useEntityInfo';
 import { styles } from './styles';
@@ -10,7 +11,7 @@ export function EntityHyperlink(props) {
     const editor = useContentfulEditor();
     const sdk = useSdkContext();
     const { target  } = props.element.data;
-    const { onEntityFetchComplete  } = props;
+    const { onEntityFetchComplete  } = useLinkTracking();
     const tooltipContent = useEntityInfo({
         target,
         sdk,

package/dist/esm/plugins/Hyperlink/createHyperlinkPlugin.js

@@ -3,7 +3,6 @@ import { INLINES } from '@contentful/rich-text-types';
 import isHotkey from 'is-hotkey';
 import { isLinkActive, unwrapLink } from '../../helpers/editor';
 import { transformRemove } from '../../helpers/transformers';
-import { withLinkTracking } from '../links-tracking';
 import { EntityHyperlink } from './components/EntityHyperlink';
 import { UrlHyperlink } from './components/UrlHyperlink';
 import { addOrEditLink } from './HyperlinkModal';
@@ -77,7 +76,7 @@ export const createHyperlinkPlugin = (sdk)=>{
                 ...common,
                 key: INLINES.ENTRY_HYPERLINK,
                 type: INLINES.ENTRY_HYPERLINK,
-                component: withLinkTracking(EntityHyperlink),
+                component: EntityHyperlink,
                 deserializeHtml: {
                     rules: [
                         {
@@ -94,7 +93,7 @@ export const createHyperlinkPlugin = (sdk)=>{
                 ...common,
                 key: INLINES.ASSET_HYPERLINK,
                 type: INLINES.ASSET_HYPERLINK,
-                component: withLinkTracking(EntityHyperlink),
+                component: EntityHyperlink,
                 deserializeHtml: {
                     rules: [
                         {

package/dist/esm/plugins/Table/onKeyDownTable.js

@@ -2,7 +2,7 @@ import { BLOCKS } from '@contentful/rich-text-types';
 import { getTableEntries, onKeyDownTable as defaultKeyDownTable } from '@udecode/plate-table';
 import { insertEmptyParagraph } from '../../helpers/editor';
 import { blurEditor } from '../../internal/misc';
-import { getAboveNode, isLastChildPath } from '../../internal/queries';
+import { getAboveNode, isLastChildPath, getText, isFirstChild } from '../../internal/queries';
 import { addRowBelow } from './actions';
 export const onKeyDownTable = (editor, plugin)=>{
     const defaultHandler = defaultKeyDownTable(editor, plugin);
@@ -30,6 +30,20 @@ export const onKeyDownTable = (editor, plugin)=>{
                 return;
             }
         }
+        if (event.key === 'Backspace') {
+            const entry = getTableEntries(editor, {});
+            if (entry) {
+                const { table , row , cell  } = entry;
+                const cellText = getText(editor, cell[1]);
+                const isFirstCell = isFirstChild(row[1]);
+                const isFirstRow = isFirstChild(table[1]);
+                if (isFirstCell && isFirstRow && !cellText) {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    return;
+                }
+            }
+        }
         if (event.key === 'Tab' && !event.shiftKey) {
             event.preventDefault();
             const entry = getTableEntries(editor, {});

package/dist/esm/plugins/Text/__tests__/createTextPlugin.test.js

@@ -7,19 +7,9 @@ describe('delete backward', ()=>{
             expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p", jsx("cursor", null))))
         },
         {
-            title: 'deletes the empty paragraph at the beginning of the RTE followed by another paragraph',
+            title: 'does not delete the very first paragraph',
             input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hp", null, "text")),
-            expected: jsx("hp", null, jsx("cursor", null), "text")
-        },
-        {
-            title: 'deletes the empty paragraph at the beginning of the RTE followed by li',
-            input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1")))),
-            expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("cursor", null), "p1")))
-        },
-        {
-            title: 'deletes the empty paragraph at the beginning of the RTE followed by a blockquote',
-            input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hquote", null, jsx("hp", null, "p1"))),
-            expected: jsx("hquote", null, jsx("hp", null, jsx("cursor", null), "p1"))
+            expected: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hp", null, "text"))
         }
     ];
     const render = (children)=>jsx("editor", null, children, jsx("hp", null, jsx("htext", null)));
@@ -44,17 +34,17 @@ describe('delete forward', ()=>{
             expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("cursor", null), "1")))
         },
         {
-            title: 'deletes the empty paragraph at the beginning of the RTE followed by another paragraph',
+            title: 'deletes the first paragraph when followed by another paragraph',
             input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hp", null, "text")),
             expected: jsx("hp", null, jsx("cursor", null), "text")
         },
         {
-            title: 'deletes the empty paragraph at the beginning of the RTE followed by li',
+            title: 'deletes the first paragraph when followed by li',
             input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1")))),
             expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("cursor", null), "p1")))
         },
         {
-            title: 'deletes the empty paragraph at the beginning of the RTE followed by a blockquote',
+            title: 'deletes the first paragraph when followed by a blockquote',
             input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hquote", null, jsx("hp", null, "p1"))),
             expected: jsx("hquote", null, jsx("hp", null, jsx("cursor", null), "p1"))
         }

package/dist/esm/plugins/Text/createTextPlugin.js

@@ -85,6 +85,7 @@ function deleteEmptyParagraph(unit, editor, deleteFunction) {
                             allow: [
                                 BLOCKS.EMBEDDED_ASSET,
                                 BLOCKS.EMBEDDED_ENTRY,
+                                BLOCKS.EMBEDDED_RESOURCE,
                                 BLOCKS.HR
                             ]
                         }),

package/dist/esm/plugins/index.js

@@ -1,4 +1,3 @@
-import { createDeserializeAstPlugin, createDeserializeHtmlPlugin } from '@udecode/plate-core';
 import { createDeserializeDocxPlugin } from '@udecode/plate-serializer-docx';
 import { createSoftBreakPlugin, createExitBreakPlugin, createResetNodePlugin } from './Break';
 import { createCommandPalettePlugin } from './CommandPalette';
@@ -6,6 +5,7 @@ import { isCommandPromptPluginEnabled } from './CommandPalette/useCommands';
 import { createDragAndDropPlugin } from './DragAndDrop';
 import { createEmbeddedAssetBlockPlugin, createEmbeddedEntryBlockPlugin } from './EmbeddedEntityBlock';
 import { createEmbeddedEntityInlinePlugin } from './EmbeddedEntityInline';
+import { createEmbeddedResourceBlockPlugin } from './EmbeddedResourceBlock';
 import { createHeadingPlugin } from './Heading';
 import { createHrPlugin } from './Hr';
 import { createHyperlinkPlugin } from './Hyperlink';
@@ -22,8 +22,6 @@ import { createTrackingPlugin } from './Tracking';
 import { createTrailingParagraphPlugin } from './TrailingParagraph';
 import { createVoidsPlugin } from './Voids';
 export const getPlugins = (sdk, onAction, restrictedMarks)=>[
-        createDeserializeHtmlPlugin(),
-        createDeserializeAstPlugin(),
         createDeserializeDocxPlugin(),
         createTrackingPlugin(onAction),
         createDragAndDropPlugin(),
@@ -38,6 +36,7 @@ export const getPlugins = (sdk, onAction, restrictedMarks)=>[
         createTablePlugin(),
         createEmbeddedEntryBlockPlugin(sdk),
         createEmbeddedAssetBlockPlugin(sdk),
+        createEmbeddedResourceBlockPlugin(sdk),
         createHyperlinkPlugin(sdk),
         createEmbeddedEntityInlinePlugin(sdk),
         createMarksPlugin(),
@@ -52,7 +51,5 @@ export const getPlugins = (sdk, onAction, restrictedMarks)=>[
         createNormalizerPlugin()
     ];
 export const disableCorePlugins = {
-    deserializeAst: true,
-    deserializeHtml: true,
     eventEditor: true
 };

package/dist/esm/plugins/links-tracking.js

@@ -1,14 +1,10 @@
-import React from 'react';
+import { useCallback } from 'react';
 import { useContentfulEditorRef } from '../ContentfulEditorProvider';
-export function withLinkTracking(Component) {
-    return function ComponentWithTracking(props) {
-        const editor = useContentfulEditorRef();
-        const onEntityFetchComplete = React.useCallback(()=>editor?.tracking.onViewportAction('linkRendered'), [
+export function useLinkTracking() {
+    const editor = useContentfulEditorRef();
+    return {
+        onEntityFetchComplete: useCallback(()=>editor?.tracking.onViewportAction('linkRendered'), [
             editor
-        ]);
-        return React.createElement(Component, {
-            ...props,
-            onEntityFetchComplete: onEntityFetchComplete
-        });
+        ])
     };
 }

package/dist/esm/plugins/{EmbeddedEntityBlock/ToolbarIcon.js → shared/EmbeddedBlockToolbarIcon.js}

@@ -1,16 +1,17 @@
 import * as React from 'react';
-import { Flex, Icon, Menu } from '@contentful/f36-components';
+import { Badge, 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 } from './Util';
+import { selectEntityAndInsert, selectResourceEntityAndInsert } from '../shared/EmbeddedBlockUtil';
 export const styles = {
     icon: css({
         marginRight: '10px'
     })
 };
-export function EmbeddedEntityBlockToolbarIcon({ isDisabled , nodeType , onClose  }) {
+export function EmbeddedBlockToolbarIcon({ isDisabled , nodeType , onClose  }) {
     const editor = useContentfulEditor();
     const sdk = useSdkContext();
     const handleClick = async (event)=>{
@@ -19,7 +20,11 @@ export function EmbeddedEntityBlockToolbarIcon({ isDisabled , nodeType , onClose
             return;
         }
         onClose();
-        await selectEntityAndInsert(nodeType, sdk, editor, editor.tracking.onToolbarAction);
+        if (nodeType == BLOCKS.EMBEDDED_RESOURCE) {
+            await selectResourceEntityAndInsert(sdk, editor, editor.tracking.onToolbarAction);
+        } else {
+            await selectEntityAndInsert(nodeType, sdk, editor, editor.tracking.onToolbarAction);
+        }
     };
     const type = getEntityTypeFromNodeType(nodeType);
     const baseClass = `rich-text__${nodeType}`;
@@ -35,11 +40,14 @@ export function EmbeddedEntityBlockToolbarIcon({ isDisabled , nodeType , onClose
         as: type === 'Asset' ? AssetIcon : EmbeddedEntryBlockIcon,
         className: `rich-text__embedded-entry-list-icon ${styles.icon}`,
         variant: "secondary"
-    }), React.createElement("span", null, type)));
+    }), 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")))));
 }
 function getEntityTypeFromNodeType(nodeType) {
     const words = nodeType.toLowerCase().split('-');
-    if (words.includes('entry')) {
+    if (words.includes('entry') || words.includes('resource')) {
         return 'Entry';
     }
     if (words.includes('asset')) {

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

@@ -0,0 +1,144 @@
+import { BLOCKS, TEXT_CONTAINERS } from '@contentful/rich-text-types';
+import isHotkey from 'is-hotkey';
+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) {
+    return (editor, { options: { hotkey  }  })=>(event)=>{
+            const [, pathToSelectedElement] = getNodeEntryFromSelection(editor, nodeType);
+            if (pathToSelectedElement) {
+                const isDelete = event.key === 'Delete';
+                const isBackspace = event.key === 'Backspace';
+                if (isDelete || isBackspace) {
+                    event.preventDefault();
+                    removeNodes(editor, {
+                        at: pathToSelectedElement
+                    });
+                }
+                return;
+            }
+            if (hotkey && isHotkey(hotkey, event)) {
+                if (nodeType === BLOCKS.EMBEDDED_RESOURCE) {
+                    selectResourceEntityAndInsert(sdk, editor, editor.tracking.onShortcutAction);
+                } else {
+                    selectEntityAndInsert(nodeType, sdk, editor, editor.tracking.onShortcutAction);
+                }
+            }
+        };
+}
+export async function selectEntityAndInsert(nodeType, sdk, editor, logAction) {
+    logAction('openCreateEmbedDialog', {
+        nodeType
+    });
+    const { field , dialogs  } = sdk;
+    const baseConfig = newEntitySelectorConfigFromRichTextField(field, nodeType);
+    const selectEntity = baseConfig.entityType === 'Asset' ? dialogs.selectSingleAsset : dialogs.selectSingleEntry;
+    const config = {
+        ...baseConfig,
+        withCreate: true
+    };
+    const { selection  } = editor;
+    const rteSlide = watchCurrentSlide(sdk.navigator);
+    const entity = await selectEntity(config);
+    if (!entity) {
+        logAction('cancelCreateEmbedDialog', {
+            nodeType
+        });
+    } else {
+        select(editor, selection);
+        insertBlock(editor, nodeType, entity);
+        ensureFollowingParagraph(editor, [
+            BLOCKS.EMBEDDED_ASSET,
+            BLOCKS.EMBEDDED_ENTRY
+        ]);
+        logAction('insert', {
+            nodeType
+        });
+    }
+    rteSlide.onActive(()=>{
+        rteSlide.unwatch();
+        focus(editor);
+    });
+}
+export async function selectResourceEntityAndInsert(sdk, editor, logAction) {
+    logAction('openCreateEmbedDialog', {
+        nodeType: BLOCKS.EMBEDDED_RESOURCE
+    });
+    const { field , dialogs  } = sdk;
+    const config = newResourceEntitySelectorConfigFromRichTextField(field, BLOCKS.EMBEDDED_RESOURCE);
+    const { selection  } = editor;
+    const entity = await dialogs.selectSingleResourceEntry(config);
+    if (!entity) {
+        logAction('cancelCreateEmbedDialog', {
+            nodeType: BLOCKS.EMBEDDED_RESOURCE
+        });
+    } else {
+        select(editor, selection);
+        insertBlock(editor, BLOCKS.EMBEDDED_RESOURCE, entity);
+        ensureFollowingParagraph(editor, [
+            BLOCKS.EMBEDDED_RESOURCE
+        ]);
+        logAction('insert', {
+            nodeType: BLOCKS.EMBEDDED_RESOURCE
+        });
+    }
+}
+function ensureFollowingParagraph(editor, nodeTypes) {
+    const entityBlock = getAboveNode(editor, {
+        match: {
+            type: nodeTypes
+        }
+    });
+    if (!entityBlock) {
+        return;
+    }
+    const level = entityBlock[1].length - 1;
+    const lastNode = getLastNodeByLevel(editor, level);
+    const isTextContainer = TEXT_CONTAINERS.includes(lastNode?.[0].type ?? '');
+    if (level !== 0 && !isTextContainer) {
+        insertEmptyParagraph(editor);
+    }
+    moveToTheNextChar(editor);
+}
+const getLink = (nodeType, entity)=>{
+    if (nodeType === BLOCKS.EMBEDDED_RESOURCE) {
+        return {
+            urn: entity.sys.urn,
+            type: 'ResourceLink',
+            linkType: 'Contentful:Entry'
+        };
+    }
+    return {
+        id: entity.sys.id,
+        type: 'Link',
+        linkType: entity.sys.type
+    };
+};
+const createNode = (nodeType, entity)=>{
+    return {
+        type: nodeType,
+        data: {
+            target: {
+                sys: getLink(nodeType, entity)
+            }
+        },
+        children: [
+            {
+                text: ''
+            }
+        ],
+        isVoid: true
+    };
+};
+function insertBlock(editor, nodeType, entity) {
+    if (!editor?.selection) return;
+    const linkedEntityBlock = createNode(nodeType, entity);
+    const hasText = editor.selection && !!getText(editor, editor.selection.focus.path);
+    if (hasText) {
+        insertNodes(editor, linkedEntityBlock);
+    } else {
+        setNodes(editor, linkedEntityBlock);
+    }
+}

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

@@ -0,0 +1,56 @@
+import * as React from 'react';
+import { EntryCard } from '@contentful/f36-components';
+import { MissingEntityCard, WrappedEntryCard, useResource } from '@contentful/field-editor-reference';
+import areEqual from 'fast-deep-equal';
+const InternalEntryCard = React.memo((props)=>{
+    if (props.status === 'loading') {
+        return React.createElement(EntryCard, {
+            isLoading: true
+        });
+    }
+    if (!props.data || props.status === 'error') {
+        return React.createElement(MissingEntityCard, {
+            entityType: "Entry",
+            isDisabled: props.isDisabled,
+            onRemove: props.onRemove
+        });
+    }
+    const { contentType , resource: entry , space  } = props.data;
+    return React.createElement(WrappedEntryCard, {
+        size: "default",
+        getAsset: ()=>Promise.resolve(),
+        isSelected: props.isSelected,
+        isDisabled: props.isDisabled,
+        localeCode: props.data.defaultLocaleCode,
+        defaultLocaleCode: props.data.defaultLocaleCode,
+        contentType: contentType,
+        spaceName: space?.name,
+        entry: entry,
+        onEdit: props.onEdit,
+        onRemove: props.isDisabled ? undefined : props.onRemove,
+        isClickable: false,
+        getEntityScheduledActions: ()=>Promise.resolve([])
+    });
+}, areEqual);
+InternalEntryCard.displayName = 'ReferenceCard';
+export const FetchingWrappedResourceCard = (props)=>{
+    const { link , onEntityFetchComplete  } = props;
+    const { data , status  } = useResource(link.linkType, link.urn);
+    React.useEffect(()=>{
+        if (status === 'success') {
+            onEntityFetchComplete?.();
+        }
+    }, [
+        onEntityFetchComplete,
+        status
+    ]);
+    return React.createElement(InternalEntryCard, {
+        data: data,
+        status: status,
+        sdk: props.sdk,
+        isDisabled: props.isDisabled,
+        isSelected: props.isSelected,
+        onEdit: props.onEdit,
+        onRemove: props.onRemove
+    });
+};

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

@@ -0,0 +1,30 @@
+import React from 'react';
+import { css } from 'emotion';
+import { IS_CHROME } from '../../helpers/environment';
+const styles = {
+    root: css({
+        marginBottom: '1.25rem !important',
+        display: 'block'
+    }),
+    container: css({
+        display: 'inline-block',
+        verticalAlign: 'text-top',
+        width: '100%'
+    })
+};
+const isResourceLink = (link)=>!!link.urn;
+export function LinkedBlockWrapper({ attributes , card , children , element  }) {
+    const link = element.data.target.sys;
+    return React.createElement("div", {
+        ...attributes,
+        className: styles.root,
+        "data-entity-type": link.linkType,
+        "data-entity-id": isResourceLink(link) ? link.urn : link.id,
+        contentEditable: IS_CHROME ? undefined : false,
+        draggable: IS_CHROME ? true : undefined
+    }, React.createElement("div", {
+        contentEditable: IS_CHROME ? false : undefined,
+        draggable: IS_CHROME ? true : undefined,
+        className: styles.container
+    }, card), children);
+}

package/dist/types/ContentfulEditorProvider.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="react" />
 import { FieldExtensionSDK } from '@contentful/app-sdk';
-import { PlateEditor } from './internal/types';
 export declare function getContentfulEditorId(sdk: FieldExtensionSDK): string;
 export declare const editorContext: import("react").Context<string>;
 export declare const ContentfulEditorIdProvider: import("react").Provider<string>;
 export declare function useContentfulEditorId(id?: string): string;
-export declare function useContentfulEditor(id?: string): PlateEditor | null;
-export declare function useContentfulEditorRef(id?: string): PlateEditor | null;
+export declare function useContentfulEditor(id?: string): import("./internal").PlateEditor;
+export declare function useContentfulEditorRef(id?: string): import("./internal").PlateEditor;