@contentful/field-editor-rich-text 3.16.8 → 3.16.10

package/dist/cjs/test-utils/validation.js

@@ -10,7 +10,7 @@ Object.defineProperty(exports, "validateRichTextDocument", {
 });
 const _richtexttypes = require("@contentful/rich-text-types");
 const _schemas = require("@contentful/rich-text-types/dist/schemas");
-const _ajv = /*#__PURE__*/ _interop_require_default(require("ajv"));
+const _ajv = _interop_require_default(require("ajv"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -75,7 +75,7 @@ function buildSchemaErrors(validateSchema, _, errors) {
     errors.push(...schemaErrors);
 }
 function resetChildNodes(node) {
-    const { content } = node;
+    const { content  } = node;
     if (isLeafNode(node)) {
         return node;
     }
@@ -84,7 +84,7 @@ function resetChildNodes(node) {
     });
 }
 function resetNode(node) {
-    const { nodeType } = node;
+    const { nodeType  } = node;
     if (_richtexttypes.helpers.isText(node)) {
         return {
             nodeType,
@@ -100,7 +100,7 @@ function resetNode(node) {
     };
 }
 function removeGrandChildNodes(node) {
-    const { content } = node;
+    const { content  } = node;
     if (isLeafNode(node)) {
         return node;
     }
@@ -119,10 +119,7 @@ function removeChildNodes(node) {
 function isLeafNode(node) {
     return _richtexttypes.helpers.isText(node) || !Array.isArray(node.content);
 }
-/**
- * Removes minItems errors occurred in grand-children to avoid
- * false positives caused by the use of `removeGrandChildNodes`
- */ function removeGrandChildrenMinItemsErrors(errors) {
+function removeGrandChildrenMinItemsErrors(errors) {
     return errors.filter((error)=>{
         const level = error.instancePath.split('/').length;
         return !(level > 3 && error.keyword === 'minItems');

package/dist/esm/ContentfulEditorProvider.js

@@ -1,7 +1,7 @@
 import { createContext, useContext } from 'react';
 import { usePlateEditorRef, usePlateEditorState } from './internal/hooks';
 export function getContentfulEditorId(sdk) {
-    const { entry, field } = sdk;
+    const { entry , field  } = sdk;
     const sys = entry.getSys();
     return `rich-text-editor-${sys.id}-${field.id}-${field.locale}`;
 }
@@ -17,14 +17,11 @@ export function useContentfulEditorId(id) {
     }
     return contextId;
 }
-// This hook re-renders when the value changes
-// Use case: Toolbar icons, for example
 export function useContentfulEditor(id) {
     const editorId = useContentfulEditorId(id);
     const editor = usePlateEditorState(editorId);
     return editor;
 }
-// This doesn't re-render when the value changes
 export function useContentfulEditorRef(id) {
     const editorId = useContentfulEditorId(id);
     const editor = usePlateEditorRef(editorId);

package/dist/esm/RichTextEditor.js

@@ -16,7 +16,7 @@ import { SyncEditorChanges } from './SyncEditorChanges';
 import Toolbar from './Toolbar';
 import StickyToolbarWrapper from './Toolbar/components/StickyToolbarWrapper';
 export const ConnectedRichTextEditor = (props)=>{
-    const { sdk, onAction, restrictedMarks } = props;
+    const { sdk , onAction , restrictedMarks  } = props;
     const id = getContentfulEditorId(sdk);
     const plugins = React.useMemo(()=>getPlugins(sdk, onAction ?? noop, restrictedMarks), [
         sdk,
@@ -37,26 +37,26 @@ export const ConnectedRichTextEditor = (props)=>{
     }) : undefined, props.maxHeight !== undefined ? css({
         maxHeight: props.maxHeight
     }) : undefined, props.isDisabled ? styles.disabled : styles.enabled, props.isToolbarHidden && styles.hiddenToolbar);
-    return /*#__PURE__*/ React.createElement(SdkProvider, {
+    return React.createElement(SdkProvider, {
         sdk: sdk
-    }, /*#__PURE__*/ React.createElement(ContentfulEditorIdProvider, {
+    }, React.createElement(ContentfulEditorIdProvider, {
         value: id
-    }, /*#__PURE__*/ React.createElement("div", {
+    }, React.createElement("div", {
         className: styles.root,
         "data-test-id": "rich-text-editor"
-    }, /*#__PURE__*/ React.createElement(PlateProvider, {
+    }, React.createElement(PlateProvider, {
         id: id,
         initialValue: initialValue,
         plugins: plugins,
         disableCorePlugins: disableCorePlugins
-    }, !props.isToolbarHidden && /*#__PURE__*/ React.createElement(StickyToolbarWrapper, {
+    }, !props.isToolbarHidden && React.createElement(StickyToolbarWrapper, {
         isDisabled: props.isDisabled
-    }, /*#__PURE__*/ React.createElement(Toolbar, {
+    }, React.createElement(Toolbar, {
         isDisabled: props.isDisabled
-    })), /*#__PURE__*/ React.createElement(SyncEditorChanges, {
+    })), React.createElement(SyncEditorChanges, {
         incomingValue: initialValue,
         onChange: props.onChange
-    }), /*#__PURE__*/ React.createElement(Plate, {
+    }), React.createElement(Plate, {
         id: id,
         editableProps: {
             className: classNames,
@@ -65,18 +65,18 @@ export const ConnectedRichTextEditor = (props)=>{
     })))));
 };
 const RichTextEditor = (props)=>{
-    const { sdk, isInitiallyDisabled, onAction, restrictedMarks, ...otherProps } = props;
+    const { sdk , isInitiallyDisabled , onAction , restrictedMarks , ...otherProps } = props;
     const isEmptyValue = React.useCallback((value)=>!value || deepEquals(value, Contentful.EMPTY_DOCUMENT), []);
     const id = getContentfulEditorId(props.sdk);
-    return /*#__PURE__*/ React.createElement(EntityProvider, {
+    return React.createElement(EntityProvider, {
         sdk: sdk
-    }, /*#__PURE__*/ React.createElement(FieldConnector, {
+    }, React.createElement(FieldConnector, {
         debounce: 0,
         field: sdk.field,
         isInitiallyDisabled: isInitiallyDisabled,
         isEmptyValue: isEmptyValue,
         isEqualValues: deepEquals
-    }, ({ lastRemoteValue, disabled, setValue })=>/*#__PURE__*/ React.createElement(ConnectedRichTextEditor, {
+    }, ({ lastRemoteValue , disabled , setValue  })=>React.createElement(ConnectedRichTextEditor, {
             ...otherProps,
             key: `rich-text-editor-${id}`,
             value: lastRemoteValue,

package/dist/esm/RichTextEditor.styles.js

@@ -27,7 +27,6 @@ export const styles = {
                 }
             }
         },
-        // We need to reset LIC style due to conflicts between PARAGRAPH styles
         'ul > li > div': {
             margin: 0
         }

package/dist/esm/SdkProvider.js

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import constate from 'constate';
-function useSdk({ sdk }) {
-    const sdkMemo = React.useMemo(()=>sdk, []); // eslint-disable-line -- TODO: explain this disable
+function useSdk({ sdk  }) {
+    const sdkMemo = React.useMemo(()=>sdk, []);
     return sdkMemo;
 }
 export const [SdkProvider, useSdkContext] = constate(useSdk);

package/dist/esm/SyncEditorChanges.js

@@ -4,12 +4,8 @@ import equal from 'fast-deep-equal';
 import { createOnChangeCallback } from './helpers/callbacks';
 import { usePlateSelectors } from './internal/hooks';
 import { setEditorValue } from './internal/transforms';
-/**
- * A hook responsible for keeping the editor state in sync with incoming
- * changes (aka. external updates
- */ const useAcceptIncomingChanges = (incomingValue)=>{
+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)) {
@@ -22,16 +18,13 @@ import { setEditorValue } from './internal/transforms';
         incomingValue
     ]);
 };
-/**
- * Attaches a custom onChange callback that
- */ const useOnValueChanged = (onChange)=>{
+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';
                 });
@@ -47,15 +40,7 @@ import { setEditorValue } from './internal/transforms';
         setEditorOnChange
     ]);
 };
-/**
- * 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 })=>{
+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(/*#__PURE__*/ React.createElement(Plate, {
+        const { getByTestId  } = render(React.createElement(Plate, {
             id: id
-        }, /*#__PURE__*/ React.createElement(SdkProvider, {
+        }, React.createElement(SdkProvider, {
             sdk: sdk
-        }, /*#__PURE__*/ React.createElement(ContentfulEditorIdProvider, {
+        }, React.createElement(ContentfulEditorIdProvider, {
             value: id
-        }, /*#__PURE__*/ React.createElement(Toolbar, {
+        }, React.createElement(Toolbar, {
             isDisabled: true
         })))));
         await waitFor(()=>{
@@ -71,13 +71,13 @@ describe('Toolbar', ()=>{
                 MARKS.SUPERSCRIPT
             ]);
             const id = getContentfulEditorId(sdk);
-            const { queryByTestId } = render(/*#__PURE__*/ React.createElement(Plate, {
+            const { queryByTestId  } = render(React.createElement(Plate, {
                 id: id
-            }, /*#__PURE__*/ React.createElement(SdkProvider, {
+            }, React.createElement(SdkProvider, {
                 sdk: sdk
-            }, /*#__PURE__*/ React.createElement(ContentfulEditorIdProvider, {
+            }, React.createElement(ContentfulEditorIdProvider, {
                 value: id
-            }, /*#__PURE__*/ React.createElement(Toolbar, {
+            }, 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(/*#__PURE__*/ React.createElement(Plate, {
+            const { queryByTestId  } = render(React.createElement(Plate, {
                 id: id
-            }, /*#__PURE__*/ React.createElement(SdkProvider, {
+            }, React.createElement(SdkProvider, {
                 sdk: sdk
-            }, /*#__PURE__*/ React.createElement(ContentfulEditorIdProvider, {
+            }, React.createElement(ContentfulEditorIdProvider, {
                 value: id
-            }, /*#__PURE__*/ React.createElement(Toolbar, {
+            }, 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,32 +17,30 @@ 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 = /*#__PURE__*/ React.createElement(React.Fragment, null, blockEntryEmbedEnabled && /*#__PURE__*/ React.createElement(EmbeddedBlockToolbarIcon, {
+    const actions = React.createElement(React.Fragment, null, blockEntryEmbedEnabled && React.createElement(EmbeddedBlockToolbarIcon, {
         isDisabled: !!isDisabled,
         nodeType: BLOCKS.EMBEDDED_ENTRY,
         onClose: onCloseEntityDropdown
-    }), blockResourceEmbedEnabled && /*#__PURE__*/ React.createElement(EmbeddedBlockToolbarIcon, {
+    }), blockResourceEmbedEnabled && React.createElement(EmbeddedBlockToolbarIcon, {
         isDisabled: !!isDisabled,
         nodeType: BLOCKS.EMBEDDED_RESOURCE,
         onClose: onCloseEntityDropdown
-    }), inlineEntryEmbedEnabled && /*#__PURE__*/ React.createElement(EmbeddedInlineToolbarIcon, {
+    }), inlineEntryEmbedEnabled && React.createElement(EmbeddedInlineToolbarIcon, {
         nodeType: INLINES.EMBEDDED_ENTRY,
         isDisabled: !!isDisabled || isLinkActive(editor),
         onClose: onCloseEntityDropdown
-    }), inlineResourceEmbedEnabled && /*#__PURE__*/ React.createElement(EmbeddedInlineToolbarIcon, {
+    }), inlineResourceEmbedEnabled && React.createElement(EmbeddedInlineToolbarIcon, {
         nodeType: INLINES.EMBEDDED_RESOURCE,
         isDisabled: !!isDisabled || isLinkActive(editor),
         onClose: onCloseEntityDropdown
-    }), blockAssetEmbedEnabled && /*#__PURE__*/ React.createElement(EmbeddedBlockToolbarIcon, {
+    }), blockAssetEmbedEnabled && React.createElement(EmbeddedBlockToolbarIcon, {
         isDisabled: !!isDisabled,
         nodeType: BLOCKS.EMBEDDED_ASSET,
         onClose: onCloseEntityDropdown
     }));
     const showEmbedButton = blockEntryEmbedEnabled || blockResourceEmbedEnabled || inlineEntryEmbedEnabled || inlineResourceEmbedEnabled || blockAssetEmbedEnabled;
-    return showEmbedButton ? /*#__PURE__*/ React.createElement(EmbeddedEntityDropdownButton, {
+    return showEmbedButton ? 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 /*#__PURE__*/ React.createElement(Menu, {
+export function EmbeddedEntityDropdownButton({ children , isDisabled , isOpen , onClose , onToggle  }) {
+    return React.createElement(Menu, {
         placement: "bottom-end",
         isOpen: isOpen,
         onClose: onClose,
         onOpen: onToggle
-    }, /*#__PURE__*/ React.createElement(Menu.Trigger, null, /*#__PURE__*/ React.createElement(Button, {
-        endIcon: /*#__PURE__*/ React.createElement(ChevronDownIcon, null),
+    }, React.createElement(Menu.Trigger, null, React.createElement(Button, {
+        endIcon: React.createElement(ChevronDownIcon, null),
         testId: "toolbar-entity-dropdown-toggle",
         variant: "secondary",
         size: "small",
-        startIcon: /*#__PURE__*/ React.createElement(PlusIcon, null),
+        startIcon: React.createElement(PlusIcon, null),
         isDisabled: isDisabled
-    }, "Embed")), /*#__PURE__*/ React.createElement(Menu.List, {
+    }, "Embed")), 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 })=>/*#__PURE__*/ React.createElement("div", {
+const StickyToolbarWrapper = ({ isDisabled , children  })=>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 /*#__PURE__*/ React.createElement(Menu, null, /*#__PURE__*/ React.createElement(Menu.Trigger, null, /*#__PURE__*/ React.createElement("span", null, /*#__PURE__*/ React.createElement(IconButton, {
+    return React.createElement(Menu, null, React.createElement(Menu.Trigger, null, React.createElement("span", null, React.createElement(IconButton, {
         size: "small",
         className: styles.toolbarBtn,
         variant: isActive ? 'secondary' : 'transparent',
-        icon: /*#__PURE__*/ React.createElement(MoreHorizontalIcon, null),
+        icon: React.createElement(MoreHorizontalIcon, null),
         "aria-label": "toggle menu",
         isDisabled: isDisabled,
         testId: "dropdown-toolbar-button"
-    }))), /*#__PURE__*/ React.createElement(Menu.List, null, isMarkEnabled(sdk.field, MARKS.SUPERSCRIPT) && /*#__PURE__*/ React.createElement(ToolbarDropdownSuperscriptButton, {
+    }))), React.createElement(Menu.List, null, isMarkEnabled(sdk.field, MARKS.SUPERSCRIPT) && React.createElement(ToolbarDropdownSuperscriptButton, {
         isDisabled: isDisabled
-    }), isMarkEnabled(sdk.field, MARKS.SUBSCRIPT) && /*#__PURE__*/ React.createElement(ToolbarDropdownSubscriptButton, {
+    }), isMarkEnabled(sdk.field, MARKS.SUBSCRIPT) && React.createElement(ToolbarDropdownSubscriptButton, {
         isDisabled: isDisabled
-    }), isMarkEnabled(sdk.field, MARKS.CODE) && /*#__PURE__*/ React.createElement(ToolbarDropdownCodeButton, {
+    }), isMarkEnabled(sdk.field, MARKS.CODE) && React.createElement(ToolbarDropdownCodeButton, {
         isDisabled: isDisabled
     })));
 };
-const Toolbar = ({ isDisabled })=>{
+const Toolbar = ({ isDisabled  })=>{
     const sdk = useSdkContext();
     const editor = useContentfulEditor();
     const canInsertBlocks = !isNodeTypeSelected(editor, BLOCKS.TABLE);
@@ -96,52 +96,51 @@ 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 /*#__PURE__*/ React.createElement(Flex, {
+    return React.createElement(Flex, {
         testId: "toolbar",
         className: styles.toolbar,
         alignItems: "center"
-    }, /*#__PURE__*/ React.createElement("div", {
+    }, React.createElement("div", {
         className: styles.formattingOptionsWrapper
-    }, /*#__PURE__*/ React.createElement(ToolbarHeadingButton, {
+    }, React.createElement(ToolbarHeadingButton, {
         isDisabled: isDisabled || !canInsertBlocks
-    }), validationInfo.isAnyMarkEnabled && /*#__PURE__*/ React.createElement("span", {
+    }), validationInfo.isAnyMarkEnabled && React.createElement("span", {
         className: styles.divider
-    }), isMarkEnabled(sdk.field, MARKS.BOLD) && /*#__PURE__*/ React.createElement(ToolbarBoldButton, {
+    }), isMarkEnabled(sdk.field, MARKS.BOLD) && React.createElement(ToolbarBoldButton, {
         isDisabled: isDisabled
-    }), isMarkEnabled(sdk.field, MARKS.ITALIC) && /*#__PURE__*/ React.createElement(ToolbarItalicButton, {
+    }), isMarkEnabled(sdk.field, MARKS.ITALIC) && React.createElement(ToolbarItalicButton, {
         isDisabled: isDisabled
-    }), isMarkEnabled(sdk.field, MARKS.UNDERLINE) && /*#__PURE__*/ React.createElement(ToolbarUnderlineButton, {
+    }), isMarkEnabled(sdk.field, MARKS.UNDERLINE) && React.createElement(ToolbarUnderlineButton, {
         isDisabled: isDisabled
-    }), !boldItalicUnderlineAvailable && isMarkEnabled(sdk.field, MARKS.SUPERSCRIPT) && /*#__PURE__*/ React.createElement(ToolbarSuperscriptButton, {
+    }), !boldItalicUnderlineAvailable && isMarkEnabled(sdk.field, MARKS.SUPERSCRIPT) && React.createElement(ToolbarSuperscriptButton, {
         isDisabled: isDisabled
-    }), !boldItalicUnderlineAvailable && isMarkEnabled(sdk.field, MARKS.SUBSCRIPT) && /*#__PURE__*/ React.createElement(ToolbarSubscriptButton, {
+    }), !boldItalicUnderlineAvailable && isMarkEnabled(sdk.field, MARKS.SUBSCRIPT) && React.createElement(ToolbarSubscriptButton, {
         isDisabled: isDisabled
-    }), !boldItalicUnderlineAvailable && isMarkEnabled(sdk.field, MARKS.CODE) && /*#__PURE__*/ React.createElement(ToolbarCodeButton, {
+    }), !boldItalicUnderlineAvailable && isMarkEnabled(sdk.field, MARKS.CODE) && React.createElement(ToolbarCodeButton, {
         isDisabled: isDisabled
-    }), shouldShowDropdown && /*#__PURE__*/ React.createElement(Dropdown, {
+    }), shouldShowDropdown && React.createElement(Dropdown, {
         sdk: sdk,
         isDisabled: isDisabled
-    }), validationInfo.isAnyHyperlinkEnabled && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement("span", {
+    }), validationInfo.isAnyHyperlinkEnabled && React.createElement(React.Fragment, null, React.createElement("span", {
         className: styles.divider
-    }), /*#__PURE__*/ React.createElement(ToolbarHyperlinkButton, {
+    }), React.createElement(ToolbarHyperlinkButton, {
         isDisabled: isDisabled
-    })), validationInfo.isAnyBlockFormattingEnabled && /*#__PURE__*/ React.createElement("span", {
+    })), validationInfo.isAnyBlockFormattingEnabled && React.createElement("span", {
         className: styles.divider
-    }), /*#__PURE__*/ React.createElement(ToolbarListButton, {
+    }), React.createElement(ToolbarListButton, {
         isDisabled: isDisabled || !canInsertBlocks
-    }), isNodeTypeEnabled(sdk.field, BLOCKS.QUOTE) && /*#__PURE__*/ React.createElement(ToolbarQuoteButton, {
+    }), isNodeTypeEnabled(sdk.field, BLOCKS.QUOTE) && React.createElement(ToolbarQuoteButton, {
         isDisabled: isDisabled || !canInsertBlocks
-    }), isNodeTypeEnabled(sdk.field, BLOCKS.HR) && /*#__PURE__*/ React.createElement(ToolbarHrButton, {
+    }), isNodeTypeEnabled(sdk.field, BLOCKS.HR) && React.createElement(ToolbarHrButton, {
         isDisabled: isDisabled || !canInsertBlocks
-    }), isNodeTypeEnabled(sdk.field, BLOCKS.TABLE) && /*#__PURE__*/ React.createElement(ToolbarTableButton, {
+    }), isNodeTypeEnabled(sdk.field, BLOCKS.TABLE) && React.createElement(ToolbarTableButton, {
         isDisabled: shouldDisableTables
-    })), /*#__PURE__*/ React.createElement("div", {
+    })), React.createElement("div", {
         className: styles.embedActionsWrapper
-    }, /*#__PURE__*/ React.createElement(EmbedEntityWidget, {
+    }, 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,7 +103,6 @@ export default {
                     isVoid: true
                 }
             }), {}),
-        // TODO: add list schema
         [BLOCKS.QUOTE]: {
             nodes: [
                 {