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

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

@@ -0,0 +1,116 @@
+import { BLOCKS } from '@contentful/rich-text-types';
+import { ELEMENT_TABLE, ELEMENT_TH, ELEMENT_TD, ELEMENT_TR, getEmptyRowNode } from '@udecode/plate-table';
+import { isBlockSelected, getAncestorPathFromSelection } from '../../helpers/editor';
+import { selectEditor } from '../../internal';
+import { getBlockAbove, getStartPoint, getAboveNode, getChildren, isFirstChildPath, isAncestorEmpty, getParentNode, isElement, getNodeEntries, getPreviousPath } from '../../internal/queries';
+import { insertNodes, removeNodes, moveNodes } from '../../internal/transforms';
+export function insertTableAndFocusFirstCell(editor) {
+    const table = {
+        type: BLOCKS.TABLE,
+        data: {},
+        children: [
+            getEmptyRowNode(editor, {
+                colCount: 2,
+                header: true
+            }),
+            getEmptyRowNode(editor, {
+                colCount: 2
+            })
+        ]
+    };
+    insertNodes(editor, table);
+    if (editor.selection) {
+        const tableEntry = getBlockAbove(editor, {
+            match: {
+                type: BLOCKS.TABLE
+            }
+        });
+        if (!tableEntry) return;
+        selectEditor(editor, {
+            at: getStartPoint(editor, tableEntry[1])
+        });
+    }
+    replaceEmptyParagraphWithTable(editor);
+}
+export function isTableActive(editor) {
+    const tableElements = [
+        ELEMENT_TABLE,
+        ELEMENT_TH,
+        ELEMENT_TR,
+        ELEMENT_TD
+    ];
+    return tableElements.some((el)=>isBlockSelected(editor, el));
+}
+export function isTableHeaderEnabled(editor) {
+    const tableItem = getAboveNode(editor, {
+        match: {
+            type: BLOCKS.TABLE
+        }
+    });
+    if (!tableItem) {
+        return false;
+    }
+    const firstRow = getChildren(tableItem)[0];
+    if (!firstRow) {
+        return false;
+    }
+    return getChildren(firstRow).every(([node])=>{
+        return node.type === BLOCKS.TABLE_HEADER_CELL;
+    });
+}
+export function replaceEmptyParagraphWithTable(editor) {
+    const tablePath = getAncestorPathFromSelection(editor);
+    if (!tablePath || isFirstChildPath(tablePath)) return;
+    const previousPath = getPreviousPath(tablePath);
+    if (!previousPath) return;
+    const [nodes] = getNodeEntries(editor, {
+        at: previousPath,
+        match: (node)=>node.type === BLOCKS.PARAGRAPH
+    });
+    if (!nodes) return;
+    const [previousNode] = nodes;
+    const isPreviousNodeTextEmpty = isAncestorEmpty(editor, previousNode);
+    if (isPreviousNodeTextEmpty) {
+        moveNodes(editor, {
+            at: tablePath,
+            to: previousPath
+        });
+        removeNodes(editor, {
+            at: tablePath
+        });
+    }
+}
+export const getNoOfMissingTableCellsInRow = (editor, rowEntry)=>{
+    const [, rowPath] = rowEntry;
+    const parent = getParentNode(editor, rowPath);
+    if (!parent) {
+        throw new Error('table rows must be wrapped in a table node');
+    }
+    const tableWidth = Math.max(...getChildren(parent).map((entry)=>getChildren(entry).length));
+    const rowWidth = getChildren(rowEntry).length;
+    return tableWidth - rowWidth;
+};
+export const createEmptyTableCells = (count)=>{
+    const emptyTableCell = {
+        type: BLOCKS.TABLE_CELL,
+        data: {},
+        children: [
+            {
+                type: BLOCKS.PARAGRAPH,
+                data: {},
+                children: [
+                    {
+                        text: ''
+                    }
+                ]
+            }
+        ]
+    };
+    return new Array(count).fill(emptyTableCell);
+};
+export const isNotEmpty = (_, entry)=>{
+    return getChildren(entry).length !== 0;
+};
+export const isTable = (node)=>{
+    return isElement(node) && node.type === BLOCKS.TABLE;
+};

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

@@ -0,0 +1,2 @@
+export * from './createTablePlugin';
+export * from './components/ToolbarButton';

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

@@ -0,0 +1,40 @@
+import { BLOCKS } from '@contentful/rich-text-types';
+import { insertEmptyParagraph } from '../../helpers/editor';
+import { getText, isElement } from '../../internal/queries';
+import { isTable } from './helpers';
+const trimUnnecessaryTableWrapper = (node)=>{
+    if (!isElement(node)) {
+        return [
+            node
+        ];
+    }
+    if (node.type !== BLOCKS.TABLE || node.children?.length !== 1) {
+        return [
+            node
+        ];
+    }
+    const row = node.children[0];
+    if (row?.children?.length !== 1) {
+        return [
+            node
+        ];
+    }
+    const cell = row.children[0];
+    return cell.children;
+};
+export const insertTableFragment = (editor)=>{
+    const { insertFragment  } = editor;
+    return (fragments)=>{
+        if (!editor.selection) {
+            return;
+        }
+        fragments = fragments.flatMap(trimUnnecessaryTableWrapper);
+        const isInsertingTable = fragments.some((fragment)=>isTable(fragment));
+        const isTableFirstFragment = fragments.findIndex((fragment)=>isTable(fragment)) === 0;
+        const currentLineHasText = getText(editor, editor.selection?.focus.path) !== '';
+        if (isInsertingTable && isTableFirstFragment && currentLineHasText) {
+            insertEmptyParagraph(editor);
+        }
+        return insertFragment(fragments);
+    };
+};

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

@@ -0,0 +1,52 @@
+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 { addRowBelow } from './actions';
+export const onKeyDownTable = (editor, plugin)=>{
+    const defaultHandler = defaultKeyDownTable(editor, plugin);
+    return (event)=>{
+        const windowSelection = window.getSelection();
+        if (windowSelection) {
+            const blockType = windowSelection.anchorNode.attributes?.['data-block-type']?.value;
+            const isBeforeTable = blockType === BLOCKS.TABLE;
+            if (isBeforeTable) {
+                if (event.key === 'Enter') {
+                    const above = getAboveNode(editor, {
+                        match: {
+                            type: BLOCKS.TABLE
+                        }
+                    });
+                    if (!above) return;
+                    const [, tablePath] = above;
+                    insertEmptyParagraph(editor, {
+                        at: tablePath,
+                        select: true
+                    });
+                }
+                event.preventDefault();
+                event.stopPropagation();
+                return;
+            }
+        }
+        if (event.key === 'Tab' && !event.shiftKey) {
+            event.preventDefault();
+            const entry = getTableEntries(editor, {});
+            if (entry) {
+                const { table , row , cell  } = entry;
+                const isLastCell = isLastChildPath(row, cell[1]);
+                const isLastRow = isLastChildPath(table, row[1]);
+                if (isLastRow && isLastCell) {
+                    addRowBelow(editor);
+                    return;
+                } else {
+                    defaultHandler(event);
+                }
+            }
+        }
+        if (event.key === 'Escape') {
+            blurEditor(editor);
+        }
+    };
+};

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

@@ -0,0 +1,46 @@
+import { BLOCKS } from '@contentful/rich-text-types';
+import { isElement } from '../../internal/queries';
+import { getPastingSource } from '../../plugins/Tracking';
+function hasTables(nodes) {
+    return nodes.some(({ type  })=>{
+        return type === BLOCKS.TABLE;
+    });
+}
+const isTableHeaderCell = ({ type  })=>type === BLOCKS.TABLE_HEADER_CELL;
+function hasHeadersOutsideFirstRow(nodes) {
+    return nodes.filter(({ type  })=>type === BLOCKS.TABLE).flatMap(({ children  })=>children.slice(1)).some(({ children  })=>children.some(isTableHeaderCell));
+}
+export function addTableTrackingEvents(editor) {
+    const { insertData  } = editor;
+    editor.insertData = (data)=>{
+        const html = data.getData('text/html');
+        if (html) {
+            const { children: markupBefore  } = editor;
+            insertData(data);
+            const { children: markupAfter  } = editor;
+            setTimeout(()=>{
+                if (hasTables(markupBefore)) return;
+                if (hasTables(markupAfter)) {
+                    editor.tracking.onViewportAction('paste', {
+                        tablePasted: true,
+                        source: getPastingSource(data),
+                        hasHeadersOutsideFirstRow: hasHeadersOutsideFirstRow(markupAfter)
+                    });
+                }
+            }, 1);
+        } else {
+            insertData(data);
+        }
+    };
+}
+export const withInvalidCellChildrenTracking = (transformer)=>{
+    return (editor, childEntry)=>{
+        const [node] = childEntry;
+        if (isElement(node)) {
+            editor.tracking?.onViewportAction('invalidTablePaste', {
+                nodeType: node.type
+            });
+        }
+        return transformer(editor, childEntry);
+    };
+};

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

@@ -0,0 +1,75 @@
+import { jsx, assertOutput, createTestEditor } from '../../../test-utils';
+describe('delete backward', ()=>{
+    const tests = [
+        {
+            title: 'deletes a character of the text inside li',
+            input: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1", jsx("cursor", null)))),
+            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',
+            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"))
+        }
+    ];
+    const render = (children)=>jsx("editor", null, children, jsx("hp", null, jsx("htext", null)));
+    for (const t of tests){
+        test(t.title, ()=>{
+            const { editor  } = createTestEditor({
+                input: render(t.input)
+            });
+            editor.deleteBackward('character');
+            assertOutput({
+                editor,
+                expected: render(t.expected)
+            });
+        });
+    }
+});
+describe('delete forward', ()=>{
+    const tests = [
+        {
+            title: 'deletes a character of the text inside li',
+            input: jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("cursor", null), "p1"))),
+            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',
+            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"))
+        }
+    ];
+    const render = (children)=>jsx("editor", null, children, jsx("hp", null, jsx("htext", null)));
+    for (const t of tests){
+        test(t.title, ()=>{
+            const { editor  } = createTestEditor({
+                input: render(t.input)
+            });
+            editor.deleteForward('character');
+            assertOutput({
+                editor,
+                expected: render(t.expected)
+            });
+        });
+    }
+});

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

@@ -0,0 +1,126 @@
+import { BLOCKS, TEXT_CONTAINERS } from '@contentful/rich-text-types';
+import { getAboveNode, isAncestorEmpty, getNodeEntries, getPointBefore, isInline, isEndPoint, getPointAfter, isRangeCollapsed, queryNode, isText } from '../../internal/queries';
+import { setSelection, select, removeNodes, splitNodes, unhangRange, unsetNodes } from '../../internal/transforms';
+export function createTextPlugin(restrictedMarks = []) {
+    return {
+        key: 'TextPlugin',
+        handlers: {
+            onMouseUp: (editor)=>()=>{
+                    if (!editor.selection) {
+                        return;
+                    }
+                    setSelection(editor, unhangRange(editor, editor.selection));
+                }
+        },
+        withOverrides: (editor)=>{
+            const { insertText  } = editor;
+            editor.insertText = (text)=>{
+                const { selection  } = editor;
+                if (selection && isRangeCollapsed(selection)) {
+                    const inlinePath = getAboveNode(editor, {
+                        match: (n)=>isInline(editor, n),
+                        mode: 'highest'
+                    })?.[1];
+                    if (inlinePath && isEndPoint(editor, selection.anchor, inlinePath)) {
+                        const point = getPointAfter(editor, inlinePath);
+                        setSelection(editor, {
+                            anchor: point,
+                            focus: point
+                        });
+                    }
+                }
+                return insertText(text);
+            };
+            const { deleteForward , deleteBackward  } = editor;
+            editor.deleteBackward = (unit)=>{
+                deleteEmptyParagraph(unit, editor, deleteBackward);
+            };
+            editor.deleteForward = (unit)=>{
+                deleteEmptyParagraph(unit, editor, deleteForward);
+            };
+            fixPasteAsPlainText(editor);
+            return editor;
+        },
+        normalizer: [
+            {
+                match: isText,
+                transform: (editor, [, path])=>{
+                    unsetNodes(editor, restrictedMarks, {
+                        at: path
+                    });
+                },
+                validNode: (_editor, [node])=>{
+                    return !restrictedMarks.some((mark)=>{
+                        return mark in node;
+                    });
+                }
+            }
+        ]
+    };
+}
+function deleteEmptyParagraph(unit, editor, deleteFunction) {
+    const entry = getAboveNode(editor, {
+        match: {
+            type: TEXT_CONTAINERS
+        }
+    });
+    if (entry) {
+        const [paragraphOrHeading, path] = entry;
+        const isTextEmpty = isAncestorEmpty(editor, paragraphOrHeading);
+        const isRootLevel = path.length === 1;
+        const hasSiblings = editor.children.length > 1;
+        if (isTextEmpty && isRootLevel && hasSiblings) {
+            removeNodes(editor, {
+                at: path
+            });
+            const prevNode = getPointBefore(editor, editor.selection, {
+                unit
+            });
+            if (prevNode) {
+                const [prevCell] = getNodeEntries(editor, {
+                    match: (node)=>queryNode([
+                            node,
+                            prevNode.path
+                        ], {
+                            allow: [
+                                BLOCKS.EMBEDDED_ASSET,
+                                BLOCKS.EMBEDDED_ENTRY,
+                                BLOCKS.HR
+                            ]
+                        }),
+                    at: prevNode
+                });
+                if (prevCell) {
+                    select(editor, prevNode);
+                }
+            }
+        } else {
+            deleteFunction(unit);
+        }
+    } else {
+        deleteFunction(unit);
+    }
+}
+function fixPasteAsPlainText(editor) {
+    editor.insertTextData = (data)=>{
+        const text = data.getData('text/plain');
+        if (!text) {
+            return false;
+        }
+        const lines = text.split(/\n{2}/);
+        let split = false;
+        for (const line of lines){
+            if (/^(\r\n?|\n)$/.test(line)) {
+                continue;
+            }
+            if (split) {
+                splitNodes(editor, {
+                    always: true
+                });
+            }
+            editor.insertText(line);
+            split = true;
+        }
+        return true;
+    };
+}

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

@@ -0,0 +1 @@
+export * from './createTextPlugin';

package/dist/esm/plugins/Tracking/createTrackingPlugin.js

@@ -0,0 +1,83 @@
+import { getCharacterCount } from './utils';
+const actionOrigin = {
+    TOOLBAR: 'toolbar-icon',
+    SHORTCUT: 'shortcut',
+    VIEWPORT: 'viewport-interaction',
+    SHORTCUT_OR_VIEWPORT: 'shortcut-or-viewport',
+    COMMAND_PALETTE: 'command-palette'
+};
+export function getPastingSource(data) {
+    const textHtml = data.getData('text/html');
+    const doc = new DOMParser().parseFromString(textHtml, 'text/html');
+    if (doc.querySelector('[id*="docs-internal-guid"]')) {
+        return 'Google Docs';
+    }
+    if (doc.querySelector('google-sheets-html-origin') || doc.querySelector('[data-sheets-value]')) {
+        return 'Google Spreadsheets';
+    }
+    if (doc.querySelector('meta[content*="Microsoft Excel"]')) {
+        return 'Microsoft Excel';
+    }
+    if (doc.querySelector('meta[content*="Microsoft Word"]')) {
+        return 'Microsoft Word';
+    }
+    if (doc.querySelector('[style*="Arial_MSFontService"]') && (doc.querySelector('.TextRun') || doc.querySelector('.OutlineElement'))) {
+        return 'Microsoft Word Online';
+    }
+    if (doc.querySelector('meta[content="Cocoa HTML Writer"]')) {
+        return 'Apple Notes';
+    }
+    if (doc.querySelector('[style*="Slack-Lato, Slack-Fractions"]')) {
+        return 'Slack';
+    }
+    return 'Unknown';
+}
+export const createTrackingPlugin = (onAction)=>{
+    const trackingActions = {
+        onViewportAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.VIEWPORT,
+                ...data
+            }),
+        onShortcutAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.SHORTCUT,
+                ...data
+            }),
+        onShortcutOrViewportAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.SHORTCUT_OR_VIEWPORT,
+                ...data
+            }),
+        onToolbarAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.TOOLBAR,
+                ...data
+            }),
+        onCommandPaletteAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.COMMAND_PALETTE,
+                ...data
+            })
+    };
+    return {
+        key: 'TrackingPlugin',
+        withOverrides: (editor)=>{
+            const { insertData  } = editor;
+            editor.tracking = trackingActions;
+            editor.insertData = (data)=>{
+                const isCopyAndPaste = data.types.length !== 0;
+                if (isCopyAndPaste) {
+                    const characterCountSelection = window.getSelection()?.toString().length;
+                    const characterCountBefore = getCharacterCount(editor);
+                    setTimeout(()=>{
+                        const characterCountAfter = getCharacterCount(editor);
+                        trackingActions.onShortcutOrViewportAction('paste', {
+                            characterCountAfter,
+                            characterCountBefore,
+                            characterCountSelection,
+                            source: getPastingSource(data)
+                        });
+                    });
+                }
+                insertData(data);
+            };
+            return editor;
+        }
+    };
+};

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

@@ -0,0 +1 @@
+export * from './createTrackingPlugin';

package/dist/esm/plugins/Tracking/utils.js

@@ -0,0 +1,10 @@
+import * as contentfulSlateJSAdapter from '@contentful/contentful-slatejs-adapter';
+import { documentToPlainTextString } from '@contentful/rich-text-plain-text-renderer';
+import Schema from '../../constants/Schema';
+export function getCharacterCount(editor) {
+    const document = contentfulSlateJSAdapter.toContentfulDocument({
+        document: editor.children,
+        schema: Schema
+    });
+    return documentToPlainTextString(document).length;
+}

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

@@ -0,0 +1,10 @@
+import { BLOCKS } from '@contentful/rich-text-types';
+import { createTrailingBlockPlugin } from '@udecode/plate-trailing-block';
+export const createTrailingParagraphPlugin = ()=>{
+    return createTrailingBlockPlugin({
+        options: {
+            type: BLOCKS.PARAGRAPH,
+            level: 0
+        }
+    });
+};

package/dist/esm/plugins/Voids/createVoidsPlugin.js

@@ -0,0 +1,21 @@
+import { isRootLevel } from '../../helpers/editor';
+import { isFirstChildPath } from '../../internal/queries';
+export const createVoidsPlugin = ()=>({
+        key: 'VoidsPlugin',
+        exitBreak: [
+            {
+                hotkey: 'enter',
+                before: true,
+                query: {
+                    filter: ([node, path])=>isRootLevel(path) && isFirstChildPath(path) && !!node.isVoid
+                }
+            },
+            {
+                hotkey: 'enter',
+                level: -2,
+                query: {
+                    filter: ([node, path])=>!(isRootLevel(path) && isFirstChildPath(path)) && !!node.isVoid
+                }
+            }
+        ]
+    });

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

@@ -0,0 +1 @@
+export * from './createVoidsPlugin';

package/dist/esm/plugins/Voids/transformVoid.js

@@ -0,0 +1,19 @@
+import { insertNodes, removeNodes } from '../../internal/transforms';
+export const transformVoid = (editor, [node, path])=>{
+    const validVoid = {
+        ...node,
+        children: [
+            {
+                text: ''
+            }
+        ]
+    };
+    removeNodes(editor, {
+        at: path
+    });
+    insertNodes(editor, [
+        validVoid
+    ], {
+        at: path
+    });
+};

package/dist/esm/plugins/index.js

@@ -0,0 +1,58 @@
+import { createDeserializeAstPlugin, createDeserializeHtmlPlugin } from '@udecode/plate-core';
+import { createDeserializeDocxPlugin } from '@udecode/plate-serializer-docx';
+import { createSoftBreakPlugin, createExitBreakPlugin, createResetNodePlugin } from './Break';
+import { createCommandPalettePlugin } from './CommandPalette';
+import { isCommandPromptPluginEnabled } from './CommandPalette/useCommands';
+import { createDragAndDropPlugin } from './DragAndDrop';
+import { createEmbeddedAssetBlockPlugin, createEmbeddedEntryBlockPlugin } from './EmbeddedEntityBlock';
+import { createEmbeddedEntityInlinePlugin } from './EmbeddedEntityInline';
+import { createHeadingPlugin } from './Heading';
+import { createHrPlugin } from './Hr';
+import { createHyperlinkPlugin } from './Hyperlink';
+import { createListPlugin } from './List';
+import { createMarksPlugin } from './Marks';
+import { createNormalizerPlugin } from './Normalizer';
+import { createParagraphPlugin } from './Paragraph';
+import { createPasteHTMLPlugin } from './PasteHTML';
+import { createQuotePlugin } from './Quote';
+import { createSelectOnBackspacePlugin } from './SelectOnBackspace';
+import { createTablePlugin } from './Table';
+import { createTextPlugin } from './Text';
+import { createTrackingPlugin } from './Tracking';
+import { createTrailingParagraphPlugin } from './TrailingParagraph';
+import { createVoidsPlugin } from './Voids';
+export const getPlugins = (sdk, onAction, restrictedMarks)=>[
+        createDeserializeHtmlPlugin(),
+        createDeserializeAstPlugin(),
+        createDeserializeDocxPlugin(),
+        createTrackingPlugin(onAction),
+        createDragAndDropPlugin(),
+        ...Object.values(isCommandPromptPluginEnabled(sdk)).some(Boolean) ? [
+            createCommandPalettePlugin()
+        ] : [],
+        createParagraphPlugin(),
+        createListPlugin(),
+        createHrPlugin(),
+        createHeadingPlugin(),
+        createQuotePlugin(),
+        createTablePlugin(),
+        createEmbeddedEntryBlockPlugin(sdk),
+        createEmbeddedAssetBlockPlugin(sdk),
+        createHyperlinkPlugin(sdk),
+        createEmbeddedEntityInlinePlugin(sdk),
+        createMarksPlugin(),
+        createTrailingParagraphPlugin(),
+        createTextPlugin(restrictedMarks),
+        createVoidsPlugin(),
+        createSelectOnBackspacePlugin(),
+        createPasteHTMLPlugin(),
+        createSoftBreakPlugin(),
+        createExitBreakPlugin(),
+        createResetNodePlugin(),
+        createNormalizerPlugin()
+    ];
+export const disableCorePlugins = {
+    deserializeAst: true,
+    deserializeHtml: true,
+    eventEditor: true
+};