@contentful/field-editor-rich-text 3.14.3 → 3.15.1

package/dist/esm/SyncEditorChanges.js

@@ -4,8 +4,12 @@ import equal from 'fast-deep-equal';
 import { createOnChangeCallback } from './helpers/callbacks';
 import { usePlateSelectors } from './internal/hooks';
 import { setEditorValue } from './internal/transforms';
-const useAcceptIncomingChanges = (incomingValue)=>{
+/**
+ * A hook responsible for keeping the editor state in sync with incoming
+ * changes (aka. external updates
+ */ const useAcceptIncomingChanges = (incomingValue)=>{
     const editor = usePlateSelectors().editor();
+    // Cache latest editor value to avoid unnecessary updates
     const lastIncomingValue = React.useRef(incomingValue);
     React.useEffect(()=>{
         if (equal(lastIncomingValue.current, incomingValue)) {
@@ -18,13 +22,16 @@ const useAcceptIncomingChanges = (incomingValue)=>{
         incomingValue
     ]);
 };
-const useOnValueChanged = (onChange)=>{
+/**
+ * Attaches a custom onChange callback that
+ */ const useOnValueChanged = (onChange)=>{
     const editor = usePlateSelectors().editor();
     const setEditorOnChange = usePlateActions().onChange();
     React.useEffect(()=>{
         const cb = createOnChangeCallback(onChange);
         setEditorOnChange({
             fn: (document)=>{
+                // Skip irrelevant events e.g. mouse selection
                 const operations = editor?.operations.filter((op)=>{
                     return op.type !== 'set_selection';
                 });
@@ -40,7 +47,15 @@ const useOnValueChanged = (onChange)=>{
         setEditorOnChange
     ]);
 };
-export const SyncEditorChanges = ({ incomingValue , onChange  })=>{
+/**
+ * A void component that's responsible for keeping the editor
+ * state in sync with incoming changes (aka. external updates) and
+ * triggering onChange events.
+ *
+ * This component is a hack to work around the limitation of Plate v17+
+ * where we can no longer access the editor instance outside the Plate
+ * provider.
+ */ export const SyncEditorChanges = ({ incomingValue, onChange })=>{
     useAcceptIncomingChanges(incomingValue);
     useOnValueChanged(onChange);
     return null;

package/dist/esm/Toolbar/_tests_/toolbar.test.js

@@ -37,13 +37,13 @@ describe('Toolbar', ()=>{
     test('everything on the toolbar should be disabled', async ()=>{
         const sdk = mockSdk();
         const id = getContentfulEditorId(sdk);
-        const { getByTestId  } = render(React.createElement(Plate, {
+        const { getByTestId } = render(/*#__PURE__*/ React.createElement(Plate, {
             id: id
-        }, React.createElement(SdkProvider, {
+        }, /*#__PURE__*/ React.createElement(SdkProvider, {
             sdk: sdk
-        }, React.createElement(ContentfulEditorIdProvider, {
+        }, /*#__PURE__*/ React.createElement(ContentfulEditorIdProvider, {
             value: id
-        }, React.createElement(Toolbar, {
+        }, /*#__PURE__*/ React.createElement(Toolbar, {
             isDisabled: true
         })))));
         await waitFor(()=>{
@@ -71,13 +71,13 @@ describe('Toolbar', ()=>{
                 MARKS.SUPERSCRIPT
             ]);
             const id = getContentfulEditorId(sdk);
-            const { queryByTestId  } = render(React.createElement(Plate, {
+            const { queryByTestId } = render(/*#__PURE__*/ React.createElement(Plate, {
                 id: id
-            }, React.createElement(SdkProvider, {
+            }, /*#__PURE__*/ React.createElement(SdkProvider, {
                 sdk: sdk
-            }, React.createElement(ContentfulEditorIdProvider, {
+            }, /*#__PURE__*/ React.createElement(ContentfulEditorIdProvider, {
                 value: id
-            }, React.createElement(Toolbar, {
+            }, /*#__PURE__*/ React.createElement(Toolbar, {
                 isDisabled: true
             })))));
             expect(queryByTestId('dropdown-toolbar-button')).toBeVisible();
@@ -89,13 +89,13 @@ describe('Toolbar', ()=>{
                 MARKS.CODE
             ]);
             const id = getContentfulEditorId(sdk);
-            const { queryByTestId  } = render(React.createElement(Plate, {
+            const { queryByTestId } = render(/*#__PURE__*/ React.createElement(Plate, {
                 id: id
-            }, React.createElement(SdkProvider, {
+            }, /*#__PURE__*/ React.createElement(SdkProvider, {
                 sdk: sdk
-            }, React.createElement(ContentfulEditorIdProvider, {
+            }, /*#__PURE__*/ React.createElement(ContentfulEditorIdProvider, {
                 value: id
-            }, React.createElement(Toolbar, {
+            }, /*#__PURE__*/ React.createElement(Toolbar, {
                 isDisabled: true
             })))));
             expect(queryByTestId('dropdown-toolbar-button')).not.toBeInTheDocument();

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

@@ -7,7 +7,7 @@ import { EmbeddedBlockToolbarIcon } from '../../plugins/shared/EmbeddedBlockTool
 import { EmbeddedInlineToolbarIcon } from '../../plugins/shared/EmbeddedInlineToolbarIcon';
 import { useSdkContext } from '../../SdkProvider';
 import { EmbeddedEntityDropdownButton } from './EmbeddedEntityDropdownButton';
-export const EmbedEntityWidget = ({ isDisabled , canInsertBlocks  })=>{
+export const EmbedEntityWidget = ({ isDisabled, canInsertBlocks })=>{
     const sdk = useSdkContext();
     const editor = useContentfulEditor();
     const [isEmbedDropdownOpen, setEmbedDropdownOpen] = useState(false);
@@ -17,30 +17,32 @@ export const EmbedEntityWidget = ({ isDisabled , canInsertBlocks  })=>{
     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;
+    // Removed access check following https://contentful.atlassian.net/browse/DANTE-486
+    // TODO: refine permissions check in order to account for tags in rules and then readd access.can('read', 'Asset')
     const blockAssetEmbedEnabled = isNodeTypeEnabled(sdk.field, BLOCKS.EMBEDDED_ASSET) && canInsertBlocks;
-    const actions = React.createElement(React.Fragment, null, blockEntryEmbedEnabled && React.createElement(EmbeddedBlockToolbarIcon, {
+    const actions = /*#__PURE__*/ React.createElement(React.Fragment, null, blockEntryEmbedEnabled && /*#__PURE__*/ React.createElement(EmbeddedBlockToolbarIcon, {
         isDisabled: !!isDisabled,
         nodeType: BLOCKS.EMBEDDED_ENTRY,
         onClose: onCloseEntityDropdown
-    }), blockResourceEmbedEnabled && React.createElement(EmbeddedBlockToolbarIcon, {
+    }), blockResourceEmbedEnabled && /*#__PURE__*/ React.createElement(EmbeddedBlockToolbarIcon, {
         isDisabled: !!isDisabled,
         nodeType: BLOCKS.EMBEDDED_RESOURCE,
         onClose: onCloseEntityDropdown
-    }), inlineEntryEmbedEnabled && React.createElement(EmbeddedInlineToolbarIcon, {
+    }), inlineEntryEmbedEnabled && /*#__PURE__*/ React.createElement(EmbeddedInlineToolbarIcon, {
         nodeType: INLINES.EMBEDDED_ENTRY,
         isDisabled: !!isDisabled || isLinkActive(editor),
         onClose: onCloseEntityDropdown
-    }), inlineResourceEmbedEnabled && React.createElement(EmbeddedInlineToolbarIcon, {
+    }), inlineResourceEmbedEnabled && /*#__PURE__*/ React.createElement(EmbeddedInlineToolbarIcon, {
         nodeType: INLINES.EMBEDDED_RESOURCE,
         isDisabled: !!isDisabled || isLinkActive(editor),
         onClose: onCloseEntityDropdown
-    }), blockAssetEmbedEnabled && React.createElement(EmbeddedBlockToolbarIcon, {
+    }), blockAssetEmbedEnabled && /*#__PURE__*/ React.createElement(EmbeddedBlockToolbarIcon, {
         isDisabled: !!isDisabled,
         nodeType: BLOCKS.EMBEDDED_ASSET,
         onClose: onCloseEntityDropdown
     }));
-    const showEmbedButton = blockEntryEmbedEnabled || blockResourceEmbedEnabled || inlineEntryEmbedEnabled || blockAssetEmbedEnabled;
-    return showEmbedButton ? React.createElement(EmbeddedEntityDropdownButton, {
+    const showEmbedButton = blockEntryEmbedEnabled || blockResourceEmbedEnabled || inlineEntryEmbedEnabled || inlineResourceEmbedEnabled || blockAssetEmbedEnabled;
+    return showEmbedButton ? /*#__PURE__*/ React.createElement(EmbeddedEntityDropdownButton, {
         isDisabled: isDisabled,
         onClose: onCloseEntityDropdown,
         onToggle: onToggleEntityDropdown,

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

@@ -1,20 +1,20 @@
 import * as React from 'react';
 import { Button, Menu } from '@contentful/f36-components';
 import { PlusIcon, ChevronDownIcon } from '@contentful/f36-icons';
-export function EmbeddedEntityDropdownButton({ children , isDisabled , isOpen , onClose , onToggle  }) {
-    return React.createElement(Menu, {
+export function EmbeddedEntityDropdownButton({ children, isDisabled, isOpen, onClose, onToggle }) {
+    return /*#__PURE__*/ React.createElement(Menu, {
         placement: "bottom-end",
         isOpen: isOpen,
         onClose: onClose,
         onOpen: onToggle
-    }, React.createElement(Menu.Trigger, null, React.createElement(Button, {
-        endIcon: React.createElement(ChevronDownIcon, null),
+    }, /*#__PURE__*/ React.createElement(Menu.Trigger, null, /*#__PURE__*/ React.createElement(Button, {
+        endIcon: /*#__PURE__*/ React.createElement(ChevronDownIcon, null),
         testId: "toolbar-entity-dropdown-toggle",
         variant: "secondary",
         size: "small",
-        startIcon: React.createElement(PlusIcon, null),
+        startIcon: /*#__PURE__*/ React.createElement(PlusIcon, null),
         isDisabled: isDisabled
-    }, "Embed")), React.createElement(Menu.List, {
+    }, "Embed")), /*#__PURE__*/ React.createElement(Menu.List, {
         className: "toolbar-entity-dropdown-list"
     }, children));
 }

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

@@ -8,7 +8,7 @@ const styles = {
     z-index: 2;
   `
 };
-const StickyToolbarWrapper = ({ isDisabled , children  })=>React.createElement("div", {
+const StickyToolbarWrapper = ({ isDisabled, children })=>/*#__PURE__*/ React.createElement("div", {
         className: isDisabled ? '' : styles.nativeSticky
     }, children);
 export default StickyToolbarWrapper;

package/dist/esm/Toolbar/index.js

@@ -67,26 +67,26 @@ const styles = {
         marginRight: '20px'
     })
 };
-const Dropdown = ({ sdk , isDisabled  })=>{
+const Dropdown = ({ sdk, isDisabled })=>{
     const editor = useContentfulEditor();
     const isActive = editor && (isMarkActive(editor, MARKS.SUPERSCRIPT) || isMarkActive(editor, MARKS.SUBSCRIPT) || isMarkActive(editor, MARKS.CODE));
-    return React.createElement(Menu, null, React.createElement(Menu.Trigger, null, React.createElement("span", null, React.createElement(IconButton, {
+    return /*#__PURE__*/ React.createElement(Menu, null, /*#__PURE__*/ React.createElement(Menu.Trigger, null, /*#__PURE__*/ React.createElement("span", null, /*#__PURE__*/ React.createElement(IconButton, {
         size: "small",
         className: styles.toolbarBtn,
         variant: isActive ? 'secondary' : 'transparent',
-        icon: React.createElement(MoreHorizontalIcon, null),
+        icon: /*#__PURE__*/ React.createElement(MoreHorizontalIcon, null),
         "aria-label": "toggle menu",
         isDisabled: isDisabled,
         testId: "dropdown-toolbar-button"
-    }))), React.createElement(Menu.List, null, isMarkEnabled(sdk.field, MARKS.SUPERSCRIPT) && React.createElement(ToolbarDropdownSuperscriptButton, {
+    }))), /*#__PURE__*/ React.createElement(Menu.List, null, isMarkEnabled(sdk.field, MARKS.SUPERSCRIPT) && /*#__PURE__*/ React.createElement(ToolbarDropdownSuperscriptButton, {
         isDisabled: isDisabled
-    }), isMarkEnabled(sdk.field, MARKS.SUBSCRIPT) && React.createElement(ToolbarDropdownSubscriptButton, {
+    }), isMarkEnabled(sdk.field, MARKS.SUBSCRIPT) && /*#__PURE__*/ React.createElement(ToolbarDropdownSubscriptButton, {
         isDisabled: isDisabled
-    }), isMarkEnabled(sdk.field, MARKS.CODE) && React.createElement(ToolbarDropdownCodeButton, {
+    }), isMarkEnabled(sdk.field, MARKS.CODE) && /*#__PURE__*/ React.createElement(ToolbarDropdownCodeButton, {
         isDisabled: isDisabled
     })));
 };
-const Toolbar = ({ isDisabled  })=>{
+const Toolbar = ({ isDisabled })=>{
     const sdk = useSdkContext();
     const editor = useContentfulEditor();
     const canInsertBlocks = !isNodeTypeSelected(editor, BLOCKS.TABLE);
@@ -96,51 +96,52 @@ const Toolbar = ({ isDisabled  })=>{
     const isListSelected = isNodeTypeSelected(editor, BLOCKS.UL_LIST) || isNodeTypeSelected(editor, BLOCKS.OL_LIST);
     const isBlockquoteSelected = isNodeTypeSelected(editor, BLOCKS.QUOTE);
     const shouldDisableTables = isDisabled || !canInsertBlocks || isListSelected || isBlockquoteSelected;
+    // We only show the dropdown when: whenever at least bold , italic and underline are available; If nothing that would go inside the dropdown is available, we hide it
     const boldItalicUnderlineAvailable = isMarkEnabled(sdk.field, MARKS.BOLD) || isMarkEnabled(sdk.field, MARKS.ITALIC) || isMarkEnabled(sdk.field, MARKS.UNDERLINE);
     const dropdownItemsAvailable = isMarkEnabled(sdk.field, MARKS.SUPERSCRIPT) || isMarkEnabled(sdk.field, MARKS.SUBSCRIPT) || isMarkEnabled(sdk.field, MARKS.CODE);
     const shouldShowDropdown = boldItalicUnderlineAvailable && dropdownItemsAvailable;
-    return React.createElement(Flex, {
+    return /*#__PURE__*/ React.createElement(Flex, {
         testId: "toolbar",
         className: styles.toolbar,
         alignItems: "center"
-    }, React.createElement("div", {
+    }, /*#__PURE__*/ React.createElement("div", {
         className: styles.formattingOptionsWrapper
-    }, React.createElement(ToolbarHeadingButton, {
+    }, /*#__PURE__*/ React.createElement(ToolbarHeadingButton, {
         isDisabled: isDisabled || !canInsertBlocks
-    }), validationInfo.isAnyMarkEnabled && React.createElement("span", {
+    }), validationInfo.isAnyMarkEnabled && /*#__PURE__*/ React.createElement("span", {
         className: styles.divider
-    }), isMarkEnabled(sdk.field, MARKS.BOLD) && React.createElement(ToolbarBoldButton, {
+    }), isMarkEnabled(sdk.field, MARKS.BOLD) && /*#__PURE__*/ React.createElement(ToolbarBoldButton, {
         isDisabled: isDisabled
-    }), isMarkEnabled(sdk.field, MARKS.ITALIC) && React.createElement(ToolbarItalicButton, {
+    }), isMarkEnabled(sdk.field, MARKS.ITALIC) && /*#__PURE__*/ React.createElement(ToolbarItalicButton, {
         isDisabled: isDisabled
-    }), isMarkEnabled(sdk.field, MARKS.UNDERLINE) && React.createElement(ToolbarUnderlineButton, {
+    }), isMarkEnabled(sdk.field, MARKS.UNDERLINE) && /*#__PURE__*/ React.createElement(ToolbarUnderlineButton, {
         isDisabled: isDisabled
-    }), !boldItalicUnderlineAvailable && isMarkEnabled(sdk.field, MARKS.SUPERSCRIPT) && React.createElement(ToolbarSuperscriptButton, {
+    }), !boldItalicUnderlineAvailable && isMarkEnabled(sdk.field, MARKS.SUPERSCRIPT) && /*#__PURE__*/ React.createElement(ToolbarSuperscriptButton, {
         isDisabled: isDisabled
-    }), !boldItalicUnderlineAvailable && isMarkEnabled(sdk.field, MARKS.SUBSCRIPT) && React.createElement(ToolbarSubscriptButton, {
+    }), !boldItalicUnderlineAvailable && isMarkEnabled(sdk.field, MARKS.SUBSCRIPT) && /*#__PURE__*/ React.createElement(ToolbarSubscriptButton, {
         isDisabled: isDisabled
-    }), !boldItalicUnderlineAvailable && isMarkEnabled(sdk.field, MARKS.CODE) && React.createElement(ToolbarCodeButton, {
+    }), !boldItalicUnderlineAvailable && isMarkEnabled(sdk.field, MARKS.CODE) && /*#__PURE__*/ React.createElement(ToolbarCodeButton, {
         isDisabled: isDisabled
-    }), shouldShowDropdown && React.createElement(Dropdown, {
+    }), shouldShowDropdown && /*#__PURE__*/ React.createElement(Dropdown, {
         sdk: sdk,
         isDisabled: isDisabled
-    }), validationInfo.isAnyHyperlinkEnabled && React.createElement(React.Fragment, null, React.createElement("span", {
+    }), validationInfo.isAnyHyperlinkEnabled && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement("span", {
         className: styles.divider
-    }), React.createElement(ToolbarHyperlinkButton, {
+    }), /*#__PURE__*/ React.createElement(ToolbarHyperlinkButton, {
         isDisabled: isDisabled
-    })), validationInfo.isAnyBlockFormattingEnabled && React.createElement("span", {
+    })), validationInfo.isAnyBlockFormattingEnabled && /*#__PURE__*/ React.createElement("span", {
         className: styles.divider
-    }), React.createElement(ToolbarListButton, {
+    }), /*#__PURE__*/ React.createElement(ToolbarListButton, {
         isDisabled: isDisabled || !canInsertBlocks
-    }), isNodeTypeEnabled(sdk.field, BLOCKS.QUOTE) && React.createElement(ToolbarQuoteButton, {
+    }), isNodeTypeEnabled(sdk.field, BLOCKS.QUOTE) && /*#__PURE__*/ React.createElement(ToolbarQuoteButton, {
         isDisabled: isDisabled || !canInsertBlocks
-    }), isNodeTypeEnabled(sdk.field, BLOCKS.HR) && React.createElement(ToolbarHrButton, {
+    }), isNodeTypeEnabled(sdk.field, BLOCKS.HR) && /*#__PURE__*/ React.createElement(ToolbarHrButton, {
         isDisabled: isDisabled || !canInsertBlocks
-    }), isNodeTypeEnabled(sdk.field, BLOCKS.TABLE) && React.createElement(ToolbarTableButton, {
+    }), isNodeTypeEnabled(sdk.field, BLOCKS.TABLE) && /*#__PURE__*/ React.createElement(ToolbarTableButton, {
         isDisabled: shouldDisableTables
-    })), React.createElement("div", {
+    })), /*#__PURE__*/ React.createElement("div", {
         className: styles.embedActionsWrapper
-    }, React.createElement(EmbedEntityWidget, {
+    }, /*#__PURE__*/ React.createElement(EmbedEntityWidget, {
         isDisabled: isDisabled,
         canInsertBlocks: canInsertBlocks
     })));

package/dist/esm/__fixtures__/FakeSdk.js

@@ -49,7 +49,7 @@ export function newReferenceEditorFakeSdk(props) {
         locales,
         cmaAdapter: createFakeCMAAdapter({
             Entry: {
-                get: async ({ entryId  })=>{
+                get: async ({ entryId })=>{
                     if (props?.fetchDelay) {
                         await delay(props.fetchDelay);
                     }
@@ -66,7 +66,7 @@ export function newReferenceEditorFakeSdk(props) {
                 }
             },
             Asset: {
-                get: async ({ assetId  })=>{
+                get: async ({ assetId })=>{
                     if (props?.fetchDelay) {
                         await delay(props.fetchDelay);
                     }
@@ -91,7 +91,7 @@ export function newReferenceEditorFakeSdk(props) {
                 }
             },
             ContentType: {
-                get: async ({ contentTypeId  })=>{
+                get: async ({ contentTypeId })=>{
                     if (contentTypeId === contentTypes.published.sys.id) {
                         return contentTypes.published;
                     }

package/dist/esm/constants/Schema.js

@@ -103,6 +103,7 @@ export default {
                     isVoid: true
                 }
             }), {}),
+        // TODO: add list schema
         [BLOCKS.QUOTE]: {
             nodes: [
                 {

package/dist/esm/dialogs/HypelinkDialog/HyperlinkDialog.js

@@ -28,7 +28,7 @@ function isFeaturingEntitySelector(entitySelectorConfigs = {}) {
     return !!entitySelectorConfigs.Entry || !!entitySelectorConfigs.Asset;
 }
 function entityToLink(entity) {
-    const { id , type  } = entity.sys;
+    const { id, type } = entity.sys;
     return {
         sys: {
             id,
@@ -48,7 +48,7 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
             }));
     }
     getValue() {
-        const { text , type , uri  } = this.state;
+        const { text, type, uri } = this.state;
         const value = {
             type
         };
@@ -63,7 +63,7 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
         return value;
     }
     isLinkComplete() {
-        const { text , type , uri , target  } = this.getValue();
+        const { text, type, uri, target } = this.getValue();
         const requiresText = !this.props.hideText;
         if (requiresText && !text) {
             return false;
@@ -71,16 +71,16 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
         return type === LINK_TYPES.URI && uri || target;
     }
     render() {
-        const { labels  } = this.props;
-        return React.createElement(EntityProvider, {
+        const { labels } = this.props;
+        return /*#__PURE__*/ React.createElement(EntityProvider, {
             sdk: this.props.sdk
-        }, React.createElement(React.Fragment, null, React.createElement(ModalContent, null, this.renderFields()), React.createElement(ModalControls, null, React.createElement(Button, {
+        }, /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(ModalContent, null, this.renderFields()), /*#__PURE__*/ React.createElement(ModalControls, null, /*#__PURE__*/ React.createElement(Button, {
             type: "button",
             onClick: ()=>this.props.onClose(null),
             variant: "secondary",
             testId: "cancel-cta",
             size: "small"
-        }, "Cancel"), React.createElement(Button, {
+        }, "Cancel"), /*#__PURE__*/ React.createElement(Button, {
             type: "submit",
             variant: "positive",
             onClick: this.handleSubmit,
@@ -90,39 +90,40 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
         }, labels.confirm))));
     }
     renderFields() {
-        const { hideText , allowedHyperlinkTypes , entitySelectorConfigs  } = this.props;
-        const { uri , text , type  } = this.state;
+        const { hideText, allowedHyperlinkTypes, entitySelectorConfigs } = this.props;
+        const { uri, text, type } = this.state;
         const isUriInputAutoFocused = type === LINK_TYPES.URI && (hideText || !!text);
-        return React.createElement(Form, null, hideText ? null : React.createElement(FormControl, {
+        return /*#__PURE__*/ React.createElement(Form, null, hideText ? null : /*#__PURE__*/ React.createElement(FormControl, {
             id: "link-text",
             isRequired: true
-        }, React.createElement(FormControl.Label, null, "Link text"), React.createElement(TextInput, {
+        }, /*#__PURE__*/ React.createElement(FormControl.Label, null, "Link text"), /*#__PURE__*/ React.createElement(TextInput, {
             testId: "link-text-input",
             name: "link-text",
             value: text || '',
             onChange: (e)=>this.setState({
                     text: e.target.value
                 }),
+            // eslint-disable-next-line -- TODO: describe this disable  jsx-a11y/no-autofocus
             autoFocus: !isUriInputAutoFocused
-        })), isFeaturingEntitySelector(entitySelectorConfigs) && React.createElement(FormControl, {
+        })), isFeaturingEntitySelector(entitySelectorConfigs) && /*#__PURE__*/ React.createElement(FormControl, {
             id: "link-type",
             name: "link-type"
-        }, React.createElement(FormControl.Label, null, "Link type"), React.createElement(Select, {
+        }, /*#__PURE__*/ React.createElement(FormControl.Label, null, "Link type"), /*#__PURE__*/ React.createElement(Select, {
             value: type,
             onChange: (e)=>this.setState({
                     type: e.target.value
                 }),
             testId: "link-type-select"
-        }, allowedHyperlinkTypes.includes(LINK_TYPES.URI) || type === LINK_TYPES.URI ? React.createElement(Select.Option, {
+        }, allowedHyperlinkTypes.includes(LINK_TYPES.URI) || type === LINK_TYPES.URI ? /*#__PURE__*/ React.createElement(Select.Option, {
             value: LINK_TYPES.URI
-        }, "URL") : null, allowedHyperlinkTypes.includes(LINK_TYPES.ENTRY) || type === LINK_TYPES.ENTRY ? React.createElement(Select.Option, {
+        }, "URL") : null, allowedHyperlinkTypes.includes(LINK_TYPES.ENTRY) || type === LINK_TYPES.ENTRY ? /*#__PURE__*/ React.createElement(Select.Option, {
             value: LINK_TYPES.ENTRY
-        }, "Entry") : null, allowedHyperlinkTypes.includes(LINK_TYPES.ASSET) || type === LINK_TYPES.ASSET ? React.createElement(Select.Option, {
+        }, "Entry") : null, allowedHyperlinkTypes.includes(LINK_TYPES.ASSET) || type === LINK_TYPES.ASSET ? /*#__PURE__*/ React.createElement(Select.Option, {
             value: LINK_TYPES.ASSET
-        }, "Asset") : null)), type === LINK_TYPES.URI ? React.createElement(FormControl, {
+        }, "Asset") : null)), type === LINK_TYPES.URI ? /*#__PURE__*/ React.createElement(FormControl, {
             id: "link-uri",
             isRequired: true
-        }, React.createElement(FormControl.Label, null, "Link target"), React.createElement(TextInput, {
+        }, /*#__PURE__*/ React.createElement(FormControl.Label, null, "Link target"), /*#__PURE__*/ React.createElement(TextInput, {
             testId: "link-target-input",
             name: "link-uri",
             value: uri || '',
@@ -130,30 +131,31 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
             onChange: (e)=>this.setState({
                     uri: e.target.value
                 }),
+            // eslint-disable-next-line -- TODO: describe this disable  jsx-a11y/no-autofocus
             autoFocus: isUriInputAutoFocused
-        }), React.createElement(FormControl.HelpText, null, "A protocol may be required, e.g. https://")) : this.renderEntityField());
+        }), /*#__PURE__*/ React.createElement(FormControl.HelpText, null, "A protocol may be required, e.g. https://")) : this.renderEntityField());
     }
     renderEntityField() {
-        const { type , entityLinks  } = this.state;
+        const { type, entityLinks } = this.state;
         const resetEntity = ()=>this.setTargetEntity(type, null);
         const entityLink = entityLinks[type];
         const isEntitySelectorVisible = !entityLink;
-        return React.createElement("div", null, React.createElement(FormLabel, {
+        return /*#__PURE__*/ React.createElement("div", null, /*#__PURE__*/ React.createElement(FormLabel, {
             required: true,
             htmlFor: ""
-        }, "Link target"), !isEntitySelectorVisible && React.createElement(TextLink, {
+        }, "Link target"), !isEntitySelectorVisible && /*#__PURE__*/ React.createElement(TextLink, {
             as: "button",
             className: css({
                 marginLeft: tokens.spacingS
             }),
             onClick: resetEntity
-        }, "Remove selection"), entityLink && React.createElement("div", null, type === LINK_TYPES.ENTRY && React.createElement(FetchingWrappedEntryCard, {
+        }, "Remove selection"), entityLink && /*#__PURE__*/ React.createElement("div", null, type === LINK_TYPES.ENTRY && /*#__PURE__*/ React.createElement(FetchingWrappedEntryCard, {
             sdk: this.props.sdk,
             locale: this.props.entitySelectorConfigs.Entry.locale,
             entryId: entityLink.sys.id,
             isDisabled: true,
             isSelected: false
-        }), type == LINK_TYPES.ASSET && React.createElement(FetchingWrappedAssetCard, {
+        }), type == LINK_TYPES.ASSET && /*#__PURE__*/ React.createElement(FetchingWrappedAssetCard, {
             sdk: this.props.sdk,
             locale: this.props.entitySelectorConfigs.Asset.locale,
             assetId: entityLink.sys.id,
@@ -162,14 +164,14 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
         })), isEntitySelectorVisible && this.renderEntitySelector(type, isEntitySelectorVisible));
     }
     renderEntitySelector(type) {
-        return React.createElement("div", {
+        return /*#__PURE__*/ React.createElement("div", {
             className: css({
                 marginTop: tokens.spacingS
             })
-        }, type === LINK_TYPES.ENTRY && React.createElement(TextLink, {
+        }, type === LINK_TYPES.ENTRY && /*#__PURE__*/ React.createElement(TextLink, {
             as: "button",
             onClick: this.selectEntry
-        }, "Select entry"), type === LINK_TYPES.ASSET && React.createElement(TextLink, {
+        }, "Select entry"), type === LINK_TYPES.ASSET && /*#__PURE__*/ React.createElement(TextLink, {
             as: "button",
             onClick: this.selectAsset
         }, "Select asset"));
@@ -181,7 +183,7 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
             this.props.onClose(this.getValue());
         });
         _define_property(this, "selectEntry", async ()=>{
-            const { locale , contentTypes  } = this.props.entitySelectorConfigs.Entry;
+            const { locale, contentTypes } = this.props.entitySelectorConfigs.Entry;
             const entry = await this.props.sdk.dialogs.selectSingleEntry({
                 locale,
                 contentTypes
@@ -189,13 +191,13 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
             this.setTargetEntity(LINK_TYPES.ENTRY, entry);
         });
         _define_property(this, "selectAsset", async ()=>{
-            const { locale  } = this.props.entitySelectorConfigs.Asset;
+            const { locale } = this.props.entitySelectorConfigs.Asset;
             const asset = await this.props.sdk.dialogs.selectSingleAsset({
                 locale
             });
             this.setTargetEntity(LINK_TYPES.ASSET, asset);
         });
-        const { text , type , uri , target  } = props.value;
+        const { text, type, uri, target } = props.value;
         const isEntityLink = Boolean(target);
         const entityLinks = {
             [LINK_TYPES.ENTRY]: null,
@@ -228,6 +230,7 @@ _define_property(HyperlinkDialog, "propTypes", {
         text: PropTypes.string,
         uri: PropTypes.string,
         target: PropTypes.object,
+        // Will be overwritten accordingly if `uri` or `target.sys.linkType` are set.
         type: PropTypes.oneOf([
             'uri',
             'Entry',
@@ -257,7 +260,7 @@ _define_property(HyperlinkDialog, "defaultProps", {
         LINK_TYPES.URI
     ]
 });
-export const openHyperlinkDialog = (dialogs, { value , showTextInput , allowedHyperlinkTypes , entitySelectorConfigs  })=>{
+export const openHyperlinkDialog = (dialogs, { value, showTextInput, allowedHyperlinkTypes, entitySelectorConfigs })=>{
     const isNew = !(value.uri || value.target);
     const props = {
         labels: {

package/dist/esm/dialogs/openRichTextDialog.js

@@ -3,8 +3,8 @@ import { ModalDialogLauncher } from '@contentful/field-editor-shared';
 import { HyperlinkDialog } from './HypelinkDialog/HyperlinkDialog';
 export const openRichTextDialog = (sdk)=>(options)=>{
         if (options.parameters?.type === 'rich-text-hyperlink-dialog') {
-            return ModalDialogLauncher.openDialog(options, ({ onClose  })=>{
-                return React.createElement(HyperlinkDialog, {
+            return ModalDialogLauncher.openDialog(options, ({ onClose })=>{
+                return /*#__PURE__*/ React.createElement(HyperlinkDialog, {
                     ...options.parameters,
                     onClose: onClose,
                     sdk: sdk

package/dist/esm/dialogs/renderRichTextDialog.js

@@ -4,11 +4,11 @@ export const renderRichTextDialog = (sdk)=>{
     const parameters = sdk.parameters.invocation;
     if (parameters?.type === 'rich-text-hyperlink-dialog') {
         sdk.window.startAutoResizer();
-        return React.createElement(HyperlinkDialog, {
+        return /*#__PURE__*/ React.createElement(HyperlinkDialog, {
             ...parameters,
             onClose: sdk.close,
             sdk: sdk
         });
     }
-    return React.createElement("div", null);
+    return /*#__PURE__*/ React.createElement("div", null);
 };

package/dist/esm/helpers/__tests__/removeInternalMarks.test.js

@@ -1,4 +1,4 @@
-import { toContentfulDocument } from '@contentful/contentful-slatejs-adapter';
+/* eslint-disable react/no-unknown-property */ /** @jsx jsx */ import { toContentfulDocument } from '@contentful/contentful-slatejs-adapter';
 import { COMMAND_PROMPT } from '../../plugins/CommandPalette/constants';
 import { jsx } from '../../test-utils';
 import { removeInternalMarks } from '../removeInternalMarks';
@@ -8,54 +8,54 @@ describe('internal mark', ()=>{
             {
                 title: 'Paragraph mark is removed',
                 input: toContentfulDocument({
-                    document: jsx("editor", null, jsx("hp", null, jsx("htext", {
+                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", {
                         [COMMAND_PROMPT]: true
                     }))).children
                 }),
                 expected: toContentfulDocument({
-                    document: jsx("editor", null, jsx("hp", null, jsx("htext", null))).children
+                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", null))).children
                 })
             },
             {
                 title: 'Heading mark is removed',
                 input: toContentfulDocument({
-                    document: jsx("editor", null, jsx("hh1", null, jsx("htext", {
+                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hh1", null, /*#__PURE__*/ jsx("htext", {
                         [COMMAND_PROMPT]: true
                     }))).children
                 }),
                 expected: toContentfulDocument({
-                    document: jsx("editor", null, jsx("hh1", null, jsx("htext", null))).children
+                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hh1", null, /*#__PURE__*/ jsx("htext", null))).children
                 })
             },
             {
                 title: 'Block quote mark is removed',
                 input: toContentfulDocument({
-                    document: jsx("editor", null, jsx("hquote", null, jsx("hp", null, jsx("htext", {
+                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hquote", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", {
                         [COMMAND_PROMPT]: true
                     })))).children
                 }),
                 expected: toContentfulDocument({
-                    document: jsx("editor", null, jsx("hquote", null, jsx("hp", null, jsx("htext", null)))).children
+                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hquote", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", null)))).children
                 })
             },
             {
                 title: 'Other marks are not removed',
                 input: toContentfulDocument({
-                    document: jsx("editor", null, jsx("hquote", null, jsx("hp", null, jsx("htext", {
+                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hquote", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", {
                         bold: true,
                         underline: true,
                         [COMMAND_PROMPT]: true
                     })))).children
                 }),
                 expected: toContentfulDocument({
-                    document: jsx("editor", null, jsx("hquote", null, jsx("hp", null, jsx("htext", {
+                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hquote", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", {
                         bold: true,
                         underline: true
                     })))).children
                 })
             }
         ];
-        for (const { input , expected , title  } of data){
+        for (const { input, expected, title } of data){
             it(`${title}`, ()=>{
                 expect(removeInternalMarks(input)).toEqual(expected);
             });