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

package/dist/esm/plugins/List/transforms/insertListItem.js

@@ -0,0 +1,82 @@
+import { BLOCKS, TEXT_CONTAINERS } from '@contentful/rich-text-types';
+import { withoutNormalizing } from '../../../internal';
+import { getAboveNode, getParentNode, isFirstChildPath, isSelectionAtBlockEnd, isSelectionAtBlockStart, getMarks, getNextPath } from '../../../internal/queries';
+import { select, insertNodes, moveChildren, splitNodes, collapseSelection } from '../../../internal/transforms';
+const emptyListItemNode = (editor, withChildren = false)=>{
+    let children = [];
+    if (withChildren) {
+        const marks = getMarks(editor) || {};
+        children = [
+            {
+                type: BLOCKS.PARAGRAPH,
+                data: {},
+                children: [
+                    {
+                        text: '',
+                        ...marks
+                    }
+                ]
+            }
+        ];
+    }
+    return {
+        type: BLOCKS.LIST_ITEM,
+        data: {},
+        children
+    };
+};
+export const insertListItem = (editor)=>{
+    if (!editor.selection) {
+        return false;
+    }
+    const paragraph = getAboveNode(editor, {
+        match: {
+            type: TEXT_CONTAINERS
+        }
+    });
+    if (!paragraph) {
+        return false;
+    }
+    const [, paragraphPath] = paragraph;
+    const listItem = getParentNode(editor, paragraphPath);
+    if (!listItem) {
+        return false;
+    }
+    const [listItemNode, listItemPath] = listItem;
+    if (listItemNode.type !== BLOCKS.LIST_ITEM) {
+        return false;
+    }
+    withoutNormalizing(editor, ()=>{
+        if (!editor.selection) {
+            return;
+        }
+        const isAtStart = isSelectionAtBlockStart(editor);
+        const isAtEnd = isSelectionAtBlockEnd(editor);
+        const isAtStartOfListItem = isAtStart && isFirstChildPath(paragraphPath);
+        const shouldSplit = !isAtStart && !isAtEnd;
+        if (shouldSplit) {
+            splitNodes(editor);
+        }
+        const newListItemPath = isAtStartOfListItem ? listItemPath : getNextPath(listItemPath);
+        insertNodes(editor, emptyListItemNode(editor, !shouldSplit), {
+            at: newListItemPath
+        });
+        const fromPath = isAtStart ? paragraphPath : getNextPath(paragraphPath);
+        const fromStartIndex = fromPath[fromPath.length - 1] || 0;
+        const toPath = newListItemPath.concat([
+            shouldSplit ? 0 : 1
+        ]);
+        if (!isAtStartOfListItem) {
+            moveChildren(editor, {
+                at: listItemPath,
+                to: toPath,
+                fromStartIndex
+            });
+        }
+        select(editor, newListItemPath);
+        collapseSelection(editor, {
+            edge: 'start'
+        });
+    });
+    return true;
+};

package/dist/esm/plugins/List/transforms/moveListItemDown.js

@@ -0,0 +1,37 @@
+import { getListTypes } from '@udecode/plate-list';
+import { withoutNormalizing } from '../../../internal/misc';
+import { getNodeEntry, getNodeChildren, getNextPath, getPreviousPath, getLastChildPath, match } from '../../../internal/queries';
+import { wrapNodes, moveNodes } from '../../../internal/transforms';
+export const moveListItemDown = (editor, { list , listItem  })=>{
+    const [listNode] = list;
+    const [, listItemPath] = listItem;
+    let previousListItemPath;
+    try {
+        previousListItemPath = getPreviousPath(listItemPath);
+    } catch (e) {
+        return;
+    }
+    const previousSiblingItem = getNodeEntry(editor, previousListItemPath);
+    if (previousSiblingItem) {
+        const [, previousPath] = previousSiblingItem;
+        const subList = Array.from(getNodeChildren(editor, previousPath)).find(([n, path])=>match(n, path, {
+                type: getListTypes(editor)
+            }));
+        const newPath = getNextPath(getLastChildPath(subList ?? previousSiblingItem));
+        withoutNormalizing(editor, ()=>{
+            if (!subList) {
+                wrapNodes(editor, {
+                    type: listNode.type,
+                    children: [],
+                    data: {}
+                }, {
+                    at: listItemPath
+                });
+            }
+            moveNodes(editor, {
+                at: listItemPath,
+                to: newPath
+            });
+        });
+    }
+};

package/dist/esm/plugins/List/transforms/moveListItems.js

@@ -0,0 +1,46 @@
+import { isListNested, ELEMENT_LIC, getListItemEntry, moveListItemUp } from '@udecode/plate-list';
+import { withoutNormalizing } from '../../../internal/misc';
+import { getNodeEntries, getPluginType, createPathRef, getParentPath, isAncestorPath } from '../../../internal/queries';
+import { moveListItemDown } from './moveListItemDown';
+export const moveListItems = (editor, { increase =true , at =editor.selection ?? undefined  } = {})=>{
+    const _nodes = getNodeEntries(editor, {
+        at,
+        match: {
+            type: getPluginType(editor, ELEMENT_LIC)
+        }
+    });
+    const lics = Array.from(_nodes);
+    if (!lics.length) return;
+    const highestLicPaths = [];
+    const highestLicPathRefs = [];
+    lics.forEach((lic)=>{
+        const licPath = lic[1];
+        const liPath = getParentPath(licPath);
+        const isAncestor = highestLicPaths.some((path)=>{
+            const highestLiPath = getParentPath(path);
+            return isAncestorPath(highestLiPath, liPath);
+        });
+        if (!isAncestor) {
+            highestLicPaths.push(licPath);
+            highestLicPathRefs.push(createPathRef(editor, licPath));
+        }
+    });
+    const licPathRefsToMove = increase ? highestLicPathRefs : highestLicPathRefs.reverse();
+    withoutNormalizing(editor, ()=>{
+        licPathRefsToMove.forEach((licPathRef)=>{
+            const licPath = licPathRef.unref();
+            if (!licPath) return;
+            const liEntry = getListItemEntry(editor, {
+                at: licPath
+            });
+            if (!liEntry) {
+                return;
+            }
+            if (increase) {
+                moveListItemDown(editor, liEntry);
+            } else if (isListNested(editor, liEntry.list[1])) {
+                moveListItemUp(editor, liEntry);
+            }
+        });
+    });
+};

package/dist/esm/plugins/List/transforms/moveListItems.test.js

@@ -0,0 +1,68 @@
+import { jsx, assertOutput, createTestEditor } from '../../../test-utils';
+import { moveListItems } from './moveListItems';
+describe('moving list items (up/down)', ()=>{
+    const renderEditor = (children)=>jsx("editor", null, children, jsx("hp", null, jsx("htext", null)));
+    const assertTab = (t, shift = false)=>{
+        test(t.title, ()=>{
+            const { editor  } = createTestEditor({
+                input: renderEditor(t.input)
+            });
+            moveListItems(editor, {
+                increase: !shift
+            });
+            assertOutput({
+                editor,
+                expected: renderEditor(t.expected)
+            });
+        });
+    };
+    const tests = [
+        {
+            title: 'single paragraph',
+            input: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1")), jsx("hli", null, jsx("hp", null, "p2", jsx("cursor", null)))),
+            expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1"), jsx("hul", null, jsx("hli", null, jsx("hp", null, "p2", jsx("cursor", null))))))
+        },
+        {
+            title: 'multiple paragraphs',
+            input: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1"), jsx("hp", null, "p2")), jsx("hli", null, jsx("hp", null, "p3", jsx("cursor", null)))),
+            expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1"), jsx("hp", null, "p2"), jsx("hul", null, jsx("hli", null, jsx("hp", null, "p3", jsx("cursor", null))))))
+        },
+        {
+            title: 'multiple elements',
+            input: jsx("hul", null, jsx("hli", null, jsx("hp", null, "a"), jsx("hp", null, "b"), jsx("hquote", null, jsx("hp", null, "quote"))), jsx("hli", null, jsx("hp", null, "c", jsx("cursor", null)), jsx("hp", null, "d"), jsx("hembed", {
+                type: "Asset",
+                id: "asset-id"
+            }))),
+            expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, "a"), jsx("hp", null, "b"), jsx("hquote", null, jsx("hp", null, "quote")), jsx("hul", null, jsx("hli", null, jsx("hp", null, "c", jsx("cursor", null)), jsx("hp", null, "d"), jsx("hembed", {
+                type: "Asset",
+                id: "asset-id"
+            })))))
+        },
+        {
+            title: 'with a sub-list',
+            input: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1"), jsx("hul", null, jsx("hli", null, jsx("hp", null, "sub p1")))), jsx("hli", null, jsx("hp", null, "p2", jsx("cursor", null)))),
+            expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1"), jsx("hul", null, jsx("hli", null, jsx("hp", null, "sub p1")), jsx("hli", null, jsx("hp", null, "p2", jsx("cursor", null))))))
+        },
+        {
+            title: 'with a sub-list as non-last child',
+            input: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1"), jsx("hul", null, jsx("hli", null, jsx("hp", null, "sub p1"))), jsx("hembed", {
+                type: "Entry",
+                id: "entry-id"
+            })), jsx("hli", null, jsx("hp", null, "p2", jsx("cursor", null)))),
+            expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1"), jsx("hul", null, jsx("hli", null, jsx("hp", null, "sub p1")), jsx("hli", null, jsx("hp", null, "p2", jsx("cursor", null)))), jsx("hembed", {
+                type: "Entry",
+                id: "entry-id"
+            })))
+        }
+    ];
+    describe('move down (aka. tab)', ()=>{
+        tests.forEach((t)=>assertTab(t));
+    });
+    describe('move up (aka. shift+tab)', ()=>{
+        tests.map((t)=>({
+                ...t,
+                input: t.expected,
+                expected: t.input
+            })).forEach((t)=>assertTab(t, true));
+    });
+});

package/dist/esm/plugins/List/transforms/toggleList.js

@@ -0,0 +1,132 @@
+import { BLOCKS } from '@contentful/rich-text-types';
+import { ELEMENT_LIC } from '@udecode/plate-list';
+import { getListItemEntry } from '@udecode/plate-list';
+import { ELEMENT_DEFAULT } from '../../../internal/constants';
+import { withoutNormalizing } from '../../../internal/misc';
+import { findNode, getNodeEntries, isRangeCollapsed, getRangeEdges, isRangeAcrossBlocks, getParentNode, getPluginType, getCommonNode, getRangeStart, getRangeEnd } from '../../../internal/queries';
+import { setNodes, wrapNodes } from '../../../internal/transforms';
+import { unwrapList } from './unwrapList';
+const listTypes = [
+    BLOCKS.UL_LIST,
+    BLOCKS.OL_LIST
+];
+export const toggleList = (editor, { type  })=>withoutNormalizing(editor, ()=>{
+        if (!editor.selection) {
+            return;
+        }
+        if (isRangeCollapsed(editor.selection) || !isRangeAcrossBlocks(editor)) {
+            const res = getListItemEntry(editor);
+            if (res) {
+                const { list  } = res;
+                if (list[0].type !== type) {
+                    setNodes(editor, {
+                        type
+                    }, {
+                        at: editor.selection,
+                        match: (n)=>listTypes.includes(n.type),
+                        mode: 'lowest'
+                    });
+                } else {
+                    unwrapList(editor);
+                }
+            } else {
+                const list = {
+                    type,
+                    children: [],
+                    data: {}
+                };
+                wrapNodes(editor, list);
+                const nodes = [
+                    ...getNodeEntries(editor, {
+                        match: {
+                            type: getPluginType(editor, ELEMENT_DEFAULT)
+                        }
+                    })
+                ];
+                const listItem = {
+                    type: BLOCKS.LIST_ITEM,
+                    children: [],
+                    data: {}
+                };
+                for (const [, path] of nodes){
+                    wrapNodes(editor, listItem, {
+                        at: path
+                    });
+                }
+            }
+        } else {
+            const [startPoint, endPoint] = getRangeEdges(editor.selection);
+            const commonEntry = getCommonNode(editor, startPoint.path, endPoint.path);
+            if (listTypes.includes(commonEntry[0].type) || commonEntry[0].type === BLOCKS.LIST_ITEM) {
+                let listType = commonEntry[0].type;
+                if (commonEntry[0].type === BLOCKS.LIST_ITEM) {
+                    listType = (getParentNode(editor, commonEntry[1])?.[0])?.type;
+                }
+                if (listType !== type) {
+                    const startList = findNode(editor, {
+                        at: getRangeStart(editor.selection),
+                        match: {
+                            type: listTypes
+                        },
+                        mode: 'lowest'
+                    });
+                    const endList = findNode(editor, {
+                        at: getRangeEnd(editor.selection),
+                        match: {
+                            type: listTypes
+                        },
+                        mode: 'lowest'
+                    });
+                    if (!startList || !endList) {
+                        return;
+                    }
+                    const rangeLength = Math.min(startList[1].length, endList[1].length);
+                    setNodes(editor, {
+                        type
+                    }, {
+                        at: editor.selection,
+                        match: (n, path)=>listTypes.includes(n.type) && path.length >= rangeLength,
+                        mode: 'all'
+                    });
+                } else {
+                    unwrapList(editor);
+                }
+            } else {
+                const rootPathLength = commonEntry[1].length;
+                const nodes = Array.from(getNodeEntries(editor, {
+                    mode: 'all'
+                })).filter(([, path])=>path.length === rootPathLength + 1).reverse();
+                nodes.forEach((n)=>{
+                    if (listTypes.includes(n[0].type)) {
+                        setNodes(editor, {
+                            type
+                        }, {
+                            at: n[1]
+                        });
+                    } else {
+                        setNodes(editor, {
+                            type: getPluginType(editor, ELEMENT_LIC)
+                        }, {
+                            at: n[1]
+                        });
+                        const listItem = {
+                            type: BLOCKS.LIST_ITEM,
+                            children: [],
+                            data: {}
+                        };
+                        wrapNodes(editor, listItem, {
+                            at: n[1]
+                        });
+                        const list = {
+                            type,
+                            children: [],
+                            data: {}
+                        };
+                        wrapNodes(editor, list, {
+                            at: n[1]
+                        });
+                    }
+                });
+            }
+        }
+    });

package/dist/esm/plugins/List/transforms/toggleList.spec.js

@@ -0,0 +1,135 @@
+import { BLOCKS } from '@contentful/rich-text-types';
+import { assertOutput, jsx, createTestEditor } from '../../../test-utils';
+import { toggleList } from './toggleList';
+describe('toggle on', ()=>{
+    it('should turn a p to list', ()=>{
+        const input = jsx("editor", null, jsx("hp", null, "1", jsx("cursor", null)));
+        const expected = jsx("editor", null, jsx("hul", null, jsx("hli", null, jsx("hp", null, "1", jsx("cursor", null)))), jsx("hp", null, jsx("htext", null)));
+        const { editor  } = createTestEditor({
+            input
+        });
+        toggleList(editor, {
+            type: BLOCKS.UL_LIST
+        });
+        assertOutput({
+            editor,
+            expected
+        });
+    });
+    it('should turn a p with a selection to list', ()=>{
+        const input = jsx("editor", null, jsx("hp", null, "Planetas ", jsx("anchor", null), "mori in", jsx("focus", null), " gandavum!"));
+        const expected = jsx("editor", null, jsx("hul", null, jsx("hli", null, jsx("hp", null, "Planetas ", jsx("anchor", null), "mori in", jsx("focus", null), " gandavum!"))), jsx("hp", null, jsx("htext", null)));
+        const { editor  } = createTestEditor({
+            input
+        });
+        toggleList(editor, {
+            type: BLOCKS.UL_LIST
+        });
+        assertOutput({
+            editor,
+            expected
+        });
+    });
+    it('should turn multiple p to list', ()=>{
+        const input = jsx("editor", null, jsx("hp", null, jsx("anchor", null), "1"), jsx("hp", null, "2"), jsx("hp", null, "3", jsx("focus", null)));
+        const expected = jsx("editor", null, jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("anchor", null), "1")), jsx("hli", null, jsx("hp", null, "2")), jsx("hli", null, jsx("hp", null, "3", jsx("focus", null)))), jsx("hp", null, jsx("htext", null)));
+        const { editor  } = createTestEditor({
+            input
+        });
+        toggleList(editor, {
+            type: BLOCKS.UL_LIST
+        });
+        assertOutput({
+            editor,
+            expected
+        });
+    });
+});
+describe('toggle off', ()=>{
+    it('should split a simple list to two', ()=>{
+        const input = jsx("editor", null, jsx("hul", null, jsx("hli", null, jsx("hp", null, "1")), jsx("hli", null, jsx("hp", null, "2", jsx("cursor", null))), jsx("hli", null, jsx("hp", null, "3"))));
+        const expected = jsx("editor", null, jsx("hul", null, jsx("hli", null, jsx("hp", null, "1"))), jsx("hp", null, "2", jsx("cursor", null)), jsx("hul", null, jsx("hli", null, jsx("hp", null, "3"))), jsx("hp", null, jsx("htext", null)));
+        const { editor  } = createTestEditor({
+            input
+        });
+        toggleList(editor, {
+            type: BLOCKS.UL_LIST
+        });
+        assertOutput({
+            editor,
+            expected
+        });
+    });
+    it('should split a nested list', ()=>{
+        const input = jsx("editor", null, jsx("hul", null, jsx("hli", null, jsx("hp", null, "1"), jsx("hul", null, jsx("hli", null, jsx("hp", null, "11")), jsx("hli", null, jsx("hp", null, "12", jsx("cursor", null))), jsx("hli", null, jsx("hp", null, "13"))))));
+        const expected = jsx("editor", null, jsx("hul", null, jsx("hli", null, jsx("hp", null, "1"), jsx("hul", null, jsx("hli", null, jsx("hp", null, "11"))))), jsx("hp", null, "12", jsx("cursor", null)), jsx("hul", null, jsx("hli", null, jsx("hp", null, "13"))), jsx("hp", null, jsx("htext", null)));
+        const { editor  } = createTestEditor({
+            input
+        });
+        toggleList(editor, {
+            type: BLOCKS.UL_LIST
+        });
+        assertOutput({
+            editor,
+            expected
+        });
+    });
+    it('should turn a list to multiple p', ()=>{
+        const input = jsx("editor", null, jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("anchor", null), "1")), jsx("hli", null, jsx("hp", null, "2")), jsx("hli", null, jsx("hp", null, "3", jsx("focus", null)))));
+        const expected = jsx("editor", null, jsx("hp", null, jsx("anchor", null), "1"), jsx("hp", null, "2"), jsx("hp", null, "3", jsx("focus", null)));
+        const { editor  } = createTestEditor({
+            input
+        });
+        toggleList(editor, {
+            type: BLOCKS.UL_LIST
+        });
+        assertOutput({
+            editor,
+            expected
+        });
+    });
+});
+describe('toggle over', ()=>{
+    it('should toggle different list types', ()=>{
+        const input = jsx("editor", null, jsx("hul", null, jsx("hli", null, jsx("hp", null, "1", jsx("cursor", null)))));
+        const expected = jsx("editor", null, jsx("hol", null, jsx("hli", null, jsx("hp", null, "1"))), jsx("hp", null, jsx("htext", null)));
+        const { editor  } = createTestEditor({
+            input
+        });
+        toggleList(editor, {
+            type: BLOCKS.OL_LIST
+        });
+        assertOutput({
+            editor,
+            expected
+        });
+    });
+    it('should only toggle the nested list', ()=>{
+        const input = jsx("editor", null, jsx("hul", null, jsx("hli", null, jsx("hp", null, "1"), jsx("hul", null, jsx("hli", null, jsx("hp", null, "11", jsx("cursor", null)))))));
+        const expected = jsx("editor", null, jsx("hul", null, jsx("hli", null, jsx("hp", null, "1"), jsx("hol", null, jsx("hli", null, jsx("hp", null, "11", jsx("cursor", null)))))), jsx("hp", null, jsx("htext", null)));
+        const { editor  } = createTestEditor({
+            input
+        });
+        toggleList(editor, {
+            type: BLOCKS.OL_LIST
+        });
+        assertOutput({
+            editor,
+            expected
+        });
+    });
+    it('should only toggle everything that is selected', ()=>{
+        const input = jsx("editor", null, jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("anchor", null), "1"), jsx("hul", null, jsx("hli", null, jsx("hp", null, "11", jsx("focus", null)))))));
+        const expected = jsx("editor", null, jsx("hol", null, jsx("hli", null, jsx("hp", null, jsx("anchor", null), "1"), jsx("hol", null, jsx("hli", null, jsx("hp", null, "11", jsx("focus", null)))))), jsx("hp", null, jsx("htext", null)));
+        const { editor  } = createTestEditor({
+            input
+        });
+        toggleList(editor, {
+            type: BLOCKS.OL_LIST
+        });
+        assertOutput({
+            editor,
+            expected
+        });
+    });
+});

package/dist/esm/plugins/List/transforms/unwrapList.js

@@ -0,0 +1,28 @@
+import { BLOCKS } from '@contentful/rich-text-types';
+import { withoutNormalizing } from '../../../internal';
+import { getNodeEntries, isElement } from '../../../internal/queries';
+import { unwrapNodes, liftNodes } from '../../../internal/transforms';
+function hasUnliftedListItems(editor, at) {
+    return getNodeEntries(editor, {
+        at,
+        match: (node, path)=>isElement(node) && node.type === BLOCKS.LIST_ITEM && path.length >= 2
+    }).next().done;
+}
+export const unwrapList = (editor, { at  } = {})=>{
+    withoutNormalizing(editor, ()=>{
+        do {
+            liftNodes(editor, {
+                at,
+                match: (node)=>isElement(node) && node.type === BLOCKS.LIST_ITEM,
+                mode: 'lowest'
+            });
+        }while (!hasUnliftedListItems(editor, at))
+        unwrapNodes(editor, {
+            at,
+            match: {
+                type: BLOCKS.LIST_ITEM
+            },
+            split: false
+        });
+    });
+};

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

@@ -0,0 +1,89 @@
+import { BLOCKS } from '@contentful/rich-text-types';
+import { isText, getCommonNode, isRangeExpanded, getRangeEdges, getChildren, getAboveNode, getBlockAbove, getParentNode } from '../../internal/queries';
+import { insertNodes, removeNodes, wrapNodes } from '../../internal/transforms';
+const isList = (node)=>[
+        BLOCKS.OL_LIST,
+        BLOCKS.UL_LIST
+    ].includes(node.type);
+export const hasListAsDirectParent = (editor, [, path])=>{
+    const [parentNode] = getParentNode(editor, path) || [];
+    return isList(parentNode);
+};
+const getNearestListAncestor = (editor, path)=>{
+    return getAboveNode(editor, {
+        at: path,
+        mode: 'lowest',
+        match: isList
+    }) || [];
+};
+export const normalizeOrphanedListItem = (editor, [, path])=>{
+    const [parentList] = getNearestListAncestor(editor, path);
+    const parentListType = parentList?.type;
+    wrapNodes(editor, {
+        type: parentListType || BLOCKS.UL_LIST,
+        children: [],
+        data: {}
+    }, {
+        at: path
+    });
+};
+export const isNonEmptyListItem = (_, entry)=>{
+    const listItemChildren = getChildren(entry);
+    return listItemChildren.length !== 0;
+};
+export const firstNodeIsNotList = (_editor, [node])=>{
+    if (node.children.length === 1) {
+        const firstNode = node.children[0];
+        return !isText(firstNode) && !isList(firstNode);
+    }
+    return true;
+};
+export const insertParagraphAsChild = (editor, [, path])=>{
+    insertNodes(editor, [
+        {
+            type: BLOCKS.PARAGRAPH,
+            data: {},
+            children: [
+                {
+                    text: ''
+                }
+            ]
+        }
+    ], {
+        at: path.concat([
+            0
+        ])
+    });
+};
+export const replaceNodeWithListItems = (editor, entry)=>{
+    const [node, path] = entry;
+    removeNodes(editor, {
+        at: path
+    });
+    insertNodes(editor, node.children[0].children, {
+        at: path
+    });
+};
+export const isListTypeActive = (editor, type)=>{
+    const { selection  } = editor;
+    if (!selection) {
+        return false;
+    }
+    if (isRangeExpanded(selection)) {
+        const [start, end] = getRangeEdges(selection);
+        const node = getCommonNode(editor, start.path, end.path);
+        if (node[0].type === type) {
+            return true;
+        }
+    }
+    const listNode = getBlockAbove(editor, {
+        match: {
+            type: [
+                BLOCKS.OL_LIST,
+                BLOCKS.UL_LIST
+            ]
+        },
+        mode: 'lowest'
+    });
+    return listNode?.[0].type === type;
+};

package/dist/esm/plugins/List/withList.js

@@ -0,0 +1,22 @@
+import { LIST_ITEM_BLOCKS } from '@contentful/rich-text-types';
+import { normalizeList, deleteFragmentList, deleteForwardList } from '@udecode/plate-list';
+import { insertListBreak } from './insertListBreak';
+import { insertListFragment } from './insertListFragment';
+const validLiChildrenTypes = LIST_ITEM_BLOCKS;
+export const withList = (editor)=>{
+    const { deleteForward , deleteFragment  } = editor;
+    editor.deleteForward = (unit)=>{
+        if (deleteForwardList(editor)) return;
+        deleteForward(unit);
+    };
+    editor.deleteFragment = ()=>{
+        if (deleteFragmentList(editor)) return;
+        deleteFragment();
+    };
+    editor.insertBreak = insertListBreak(editor);
+    editor.insertFragment = insertListFragment(editor);
+    editor.normalizeNode = normalizeList(editor, {
+        validLiChildrenTypes
+    });
+    return editor;
+};