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

package/dist/cjs/plugins/Table/components/Table.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Table", {
+    enumerable: true,
+    get: function() {
+        return Table;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36tokens = _interop_require_default(require("@contentful/f36-tokens"));
+const _richtexttypes = require("@contentful/rich-text-types");
+const _emotion = require("emotion");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const style = (0, _emotion.css)`
+  margin-bottom: 1.5em;
+  border-collapse: collapse;
+  border-radius: 5px;
+  border-style: hidden;
+  box-shadow: 0 0 0 1px ${_f36tokens.default.gray400};
+  width: 100%;
+  table-layout: fixed;
+  overflow: hidden;
+`;
+const Table = (props)=>{
+    return _react.createElement("div", {
+        "data-block-type": _richtexttypes.BLOCKS.TABLE
+    }, _react.createElement("table", {
+        className: style,
+        ...props.attributes
+    }, _react.createElement("tbody", null, props.children)));
+};

package/dist/cjs/plugins/Table/components/TableActions.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    styles: function() {
+        return styles;
+    },
+    TableActions: function() {
+        return TableActions;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36components = require("@contentful/f36-components");
+const _f36icons = require("@contentful/f36-icons");
+const _richtexttypes = require("@contentful/rich-text-types");
+const _platetable = require("@udecode/plate-table");
+const _emotion = require("emotion");
+const _ContentfulEditorProvider = require("../../../ContentfulEditorProvider");
+const _editor = require("../../../helpers/editor");
+const _internal = require("../../../internal");
+const _hooks = require("../../../internal/hooks");
+const _queries = require("../../../internal/queries");
+const _actions = require("../actions");
+const _helpers = require("../helpers");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const styles = {
+    topRight: (0, _emotion.css)({
+        position: 'absolute',
+        top: '6px',
+        right: '5px'
+    })
+};
+const getCurrentTableSize = (editor)=>{
+    const [table] = (0, _editor.getNodeEntryFromSelection)(editor, _richtexttypes.BLOCKS.TABLE);
+    return table ? (0, _editor.getTableSize)(table) : null;
+};
+const TableActions = ()=>{
+    const editor = (0, _ContentfulEditorProvider.useContentfulEditor)();
+    const isDisabled = (0, _hooks.useReadOnly)();
+    const [isOpen, setOpen] = _react.useState(false);
+    const [isHeaderEnabled, setHeaderEnabled] = _react.useState(false);
+    const close = _react.useCallback(()=>{
+        setOpen(false);
+    }, []);
+    _react.useEffect(()=>{
+        setHeaderEnabled(Boolean(editor && (0, _helpers.isTableHeaderEnabled)(editor)));
+    }, [
+        editor
+    ]);
+    const canInsertRowAbove = _react.useMemo(()=>{
+        if (!editor) {
+            return false;
+        }
+        const headerCell = (0, _queries.getAboveNode)(editor, {
+            match: {
+                type: _richtexttypes.BLOCKS.TABLE_HEADER_CELL
+            }
+        });
+        return !headerCell;
+    }, [
+        editor
+    ]);
+    const toggleHeader = _react.useCallback(()=>{
+        close();
+        if (!editor) {
+            return;
+        }
+        const value = !isHeaderEnabled;
+        setHeaderEnabled(value);
+        (0, _actions.setHeader)(editor, value);
+    }, [
+        editor,
+        close,
+        isHeaderEnabled
+    ]);
+    const action = _react.useCallback((cb, type, element)=>()=>{
+            if (!editor?.selection) return;
+            close();
+            const tableSize = getCurrentTableSize(editor);
+            (0, _internal.withoutNormalizing)(editor, ()=>{
+                cb(editor, {
+                    header: isHeaderEnabled
+                });
+            });
+            const actionName = `${type}Table${element === 'Table' ? '' : element}`;
+            editor.tracking.onViewportAction(actionName, {
+                tableSize
+            });
+        }, [
+        editor,
+        isHeaderEnabled,
+        close
+    ]);
+    if (isDisabled) {
+        return null;
+    }
+    return _react.createElement(_f36components.Menu, {
+        placement: "left",
+        isOpen: isOpen,
+        onOpen: ()=>{
+            setOpen(true);
+        },
+        onClose: close
+    }, _react.createElement(_f36components.Menu.Trigger, null, _react.createElement(_f36components.IconButton, {
+        size: "small",
+        variant: "transparent",
+        tabIndex: -1,
+        className: styles.topRight,
+        icon: _react.createElement(_f36icons.ChevronDownIcon, null),
+        "aria-label": "Open table menu",
+        testId: "cf-table-actions-button"
+    })), _react.createElement(_f36components.Menu.List, null, _react.createElement(_f36components.Menu.Item, {
+        onClick: action(_actions.addRowAbove, 'insert', 'Row'),
+        disabled: !canInsertRowAbove
+    }, "Add row above"), _react.createElement(_f36components.Menu.Item, {
+        onClick: action(_actions.addRowBelow, 'insert', 'Row')
+    }, "Add row below"), _react.createElement(_f36components.Menu.Item, {
+        onClick: action(_actions.addColumnLeft, 'insert', 'Column')
+    }, "Add column left"), _react.createElement(_f36components.Menu.Item, {
+        onClick: action(_actions.addColumnRight, 'insert', 'Column')
+    }, "Add column right"), _react.createElement(_f36components.Menu.Divider, null), _react.createElement(_f36components.Menu.Item, {
+        onClick: toggleHeader
+    }, isHeaderEnabled ? 'Disable table header' : 'Enable table header'), _react.createElement(_f36components.Menu.Divider, null), _react.createElement(_f36components.Menu.Item, {
+        onClick: action(_platetable.deleteRow, 'remove', 'Row')
+    }, "Delete row"), _react.createElement(_f36components.Menu.Item, {
+        onClick: action(_platetable.deleteColumn, 'remove', 'Column')
+    }, "Delete column"), _react.createElement(_f36components.Menu.Item, {
+        onClick: action(_platetable.deleteTable, 'remove', 'Table')
+    }, "Delete table")));
+};

package/dist/cjs/plugins/Table/components/ToolbarButton.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolbarTableButton", {
+    enumerable: true,
+    get: function() {
+        return ToolbarTableButton;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36icons = require("@contentful/f36-icons");
+const _ContentfulEditorProvider = require("../../../ContentfulEditorProvider");
+const _editor = require("../../../helpers/editor");
+const _ToolbarButton = require("../../shared/ToolbarButton");
+const _helpers = require("./../helpers");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function ToolbarTableButton(props) {
+    const editor = (0, _ContentfulEditorProvider.useContentfulEditor)();
+    const isActive = editor && (0, _helpers.isTableActive)(editor);
+    async function handleClick() {
+        if (!editor) return;
+        editor.tracking.onToolbarAction('insertTable');
+        (0, _helpers.insertTableAndFocusFirstCell)(editor);
+        (0, _editor.focus)(editor);
+    }
+    if (!editor) return null;
+    return _react.createElement(_ToolbarButton.ToolbarButton, {
+        title: "Table",
+        testId: "table-toolbar-button",
+        onClick: handleClick,
+        isActive: !!isActive,
+        isDisabled: props.isDisabled
+    }, _react.createElement(_f36icons.TableIcon, null));
+}

package/dist/cjs/plugins/Table/createTablePlugin.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createTablePlugin", {
+    enumerable: true,
+    get: function() {
+        return createTablePlugin;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _platetable = require("@udecode/plate-table");
+const _editor = require("../../helpers/editor");
+const _transformers = require("../../helpers/transformers");
+const _queries = require("../../internal/queries");
+const _transforms = require("../../internal/transforms");
+const _Cell = require("./components/Cell");
+const _HeaderCell = require("./components/HeaderCell");
+const _Row = require("./components/Row");
+const _Table = require("./components/Table");
+const _helpers = require("./helpers");
+const _insertTableFragment = require("./insertTableFragment");
+const _onKeyDownTable = require("./onKeyDownTable");
+const _tableTracking = require("./tableTracking");
+const createTablePlugin = ()=>(0, _platetable.createTablePlugin)({
+        type: _richtexttypes.BLOCKS.TABLE,
+        handlers: {
+            onKeyDown: _onKeyDownTable.onKeyDownTable
+        },
+        withOverrides: (editor, plugin)=>{
+            const { normalizeNode  } = editor;
+            (0, _platetable.withTable)(editor, plugin);
+            editor.normalizeNode = normalizeNode;
+            (0, _tableTracking.addTableTrackingEvents)(editor);
+            editor.insertFragment = (0, _insertTableFragment.insertTableFragment)(editor);
+            return editor;
+        },
+        overrideByKey: {
+            [_platetable.ELEMENT_TABLE]: {
+                type: _richtexttypes.BLOCKS.TABLE,
+                component: _Table.Table,
+                normalizer: [
+                    {
+                        validNode: _helpers.isNotEmpty
+                    },
+                    {
+                        validNode: (editor, [, path])=>{
+                            const isNestedTable = !!(0, _queries.getBlockAbove)(editor, {
+                                at: path,
+                                match: {
+                                    type: [
+                                        _richtexttypes.BLOCKS.TABLE_CELL,
+                                        _richtexttypes.BLOCKS.TABLE_HEADER_CELL
+                                    ]
+                                }
+                            });
+                            return (0, _editor.isRootLevel)(path) || isNestedTable;
+                        },
+                        transform: _transformers.transformLift
+                    },
+                    {
+                        validChildren: _richtexttypes.CONTAINERS[_richtexttypes.BLOCKS.TABLE]
+                    }
+                ]
+            },
+            [_platetable.ELEMENT_TR]: {
+                type: _richtexttypes.BLOCKS.TABLE_ROW,
+                component: _Row.Row,
+                normalizer: [
+                    {
+                        validChildren: _richtexttypes.CONTAINERS[_richtexttypes.BLOCKS.TABLE_ROW],
+                        transform: (0, _transformers.transformWrapIn)(_richtexttypes.BLOCKS.TABLE_CELL)
+                    },
+                    {
+                        validNode: _helpers.isNotEmpty
+                    },
+                    {
+                        validNode: (editor, [, path])=>{
+                            const parent = (0, _queries.getParentNode)(editor, path)?.[0];
+                            return parent && parent.type === _richtexttypes.BLOCKS.TABLE;
+                        },
+                        transform: (0, _transformers.transformWrapIn)(_richtexttypes.BLOCKS.TABLE)
+                    },
+                    {
+                        validNode: (editor, entry)=>{
+                            return (0, _helpers.getNoOfMissingTableCellsInRow)(editor, entry) === 0;
+                        },
+                        transform: (editor, entry)=>{
+                            const howMany = (0, _helpers.getNoOfMissingTableCellsInRow)(editor, entry);
+                            const at = (0, _queries.getNextPath)((0, _queries.getLastChildPath)(entry));
+                            (0, _transforms.insertNodes)(editor, (0, _helpers.createEmptyTableCells)(howMany), {
+                                at
+                            });
+                        }
+                    }
+                ]
+            },
+            [_platetable.ELEMENT_TH]: {
+                type: _richtexttypes.BLOCKS.TABLE_HEADER_CELL,
+                component: _HeaderCell.HeaderCell,
+                normalizer: [
+                    {
+                        validChildren: _richtexttypes.CONTAINERS[_richtexttypes.BLOCKS.TABLE_HEADER_CELL],
+                        transform: (0, _tableTracking.withInvalidCellChildrenTracking)(_transformers.transformParagraphs)
+                    }
+                ]
+            },
+            [_platetable.ELEMENT_TD]: {
+                type: _richtexttypes.BLOCKS.TABLE_CELL,
+                component: _Cell.Cell,
+                normalizer: [
+                    {
+                        validChildren: _richtexttypes.CONTAINERS[_richtexttypes.BLOCKS.TABLE_CELL],
+                        transform: (0, _tableTracking.withInvalidCellChildrenTracking)(_transformers.transformParagraphs)
+                    }
+                ]
+            }
+        }
+    });

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./createTablePlugin"), exports);
+_export_star(require("./components/ToolbarButton"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "insertTableFragment", {
+    enumerable: true,
+    get: function() {
+        return insertTableFragment;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _editor = require("../../helpers/editor");
+const _queries = require("../../internal/queries");
+const _helpers = require("./helpers");
+const trimUnnecessaryTableWrapper = (node)=>{
+    if (!(0, _queries.isElement)(node)) {
+        return [
+            node
+        ];
+    }
+    if (node.type !== _richtexttypes.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;
+};
+const insertTableFragment = (editor)=>{
+    const { insertFragment  } = editor;
+    return (fragments)=>{
+        if (!editor.selection) {
+            return;
+        }
+        fragments = fragments.flatMap(trimUnnecessaryTableWrapper);
+        const isInsertingTable = fragments.some((fragment)=>(0, _helpers.isTable)(fragment));
+        const isTableFirstFragment = fragments.findIndex((fragment)=>(0, _helpers.isTable)(fragment)) === 0;
+        const currentLineHasText = (0, _queries.getText)(editor, editor.selection?.focus.path) !== '';
+        if (isInsertingTable && isTableFirstFragment && currentLineHasText) {
+            (0, _editor.insertEmptyParagraph)(editor);
+        }
+        return insertFragment(fragments);
+    };
+};