@worktile/theia 3.0.9 → 3.1.0-next.0

package/esm2020/plugins/list/list.plugin.mjs

@@ -0,0 +1,286 @@
+import { Transforms, Node, Editor, Path } from 'slate';
+import { AngularEditor, getPlainText } from 'slate-angular';
+import { CLIPBOARD_FORMAT_KEY, ElementKinds } from '../../constants';
+import * as TheQueries from '../../queries';
+import * as TheTransforms from '../../transforms';
+import { isList } from './queries/is-list';
+import { isInList } from './queries/is-in-list';
+import { isListNested } from './queries/is-list-nested';
+import { getListTypes } from './queries/get-list-types';
+import { getStartListItem } from './queries/get-start-list-item';
+import { isSingleListItem } from './queries/is-single-list-item';
+import { getListItemEntry } from './queries/get-list-item-entry';
+import { hasListInListItem, hasStableListInListItem, hasStableListItem } from './queries/has-list-in-list-item';
+import { isSelectionAtListItemStart } from './queries/is-selection-at-list-item-start';
+import { insertListData } from './transforms/insert-list-data';
+import { moveListItemUp } from './transforms/move-list-item-up';
+import { insertListItem } from './transforms/insert-list-item';
+import { unwrapList } from './transforms/unwrap-list';
+import { moveListItemSublistItemsToListItemSublist } from './transforms/move-list-item-sublist-items-to-list-item-sublist';
+import { getListNormalizer } from './normalizers/get-list-normalizer';
+import { onKeyDownList } from './on-key-down-list';
+import { TheNumberedListComponent } from './components/numbered-list.component';
+import { TheBulletedListComponent } from './components/bulleted-list.component';
+import { TheListItemComponent } from './components/list-item.component';
+import { extractFragment } from '../../utils/fragment';
+import { isSelectionInSameListItem } from './queries/is-selection-in-same-list-item';
+import { createPluginFactory, getPluginOptions } from '../../core';
+import { PluginKeys } from '../../interfaces';
+import { ListEditor } from './list.editor';
+export const withList = (editor) => {
+    const { insertBreak, deleteBackward, onKeydown, insertData, setFragmentData, renderElement } = editor;
+    const validLiChildrenTypes = getPluginOptions(editor, PluginKeys.list)?.validLiChildrenTypes ?? [];
+    const resetBlockTypesListRule = {
+        types: [ElementKinds.listItem],
+        defaultType: ElementKinds.paragraph,
+        onReset: (_editor) => unwrapList(_editor)
+    };
+    editor.insertBreak = () => {
+        const node = TheQueries.anchorBlock(editor);
+        if (!node) {
+            insertBreak();
+            return;
+        }
+        const isVoid = Editor.isVoid(editor, node);
+        if (isVoid) {
+            insertBreak();
+            return;
+        }
+        const listEntry = getListItemEntry(editor, {});
+        if (listEntry) {
+            let moved;
+            const { list, listItem } = listEntry;
+            const [listItemNode, listItemPath] = listItem;
+            const cursor = editor.selection.focus;
+            const isStart = Editor.isStart(editor, cursor, listItemPath);
+            // deprecated
+            // 如果有子级
+            if (hasListInListItem(listItemNode)) {
+                /**
+                 * If selection is at the end of li,
+                 * insert below li where children will be moved.
+                 */
+                if (Editor.isEnd(editor, cursor, listItemPath)) {
+                    return Transforms.insertNodes(editor, {
+                        type: ElementKinds.listItem,
+                        children: [{ type: ElementKinds.paragraph, children: [{ text: '' }] }]
+                    }, { at: Path.next(listItemPath), select: true });
+                }
+                /**
+                 * 如果选区是在listItem的开头，则在listItem上方插入
+                 */
+                if (isStart) {
+                    return Transforms.insertNodes(editor, {
+                        type: ElementKinds.listItem,
+                        children: [{ type: ElementKinds.paragraph, children: [{ text: '' }] }]
+                    }, { at: listItemPath });
+                }
+            }
+            // 如果选择的listItem为空则将其向上移动
+            if (isStart && TheQueries.isBlockAboveEmpty(editor)) {
+                moved = moveListItemUp(editor, { list, listItem });
+                if (moved)
+                    return;
+            }
+            const didReset = TheTransforms.onKeyDownResetBlockType({
+                rules: [
+                    {
+                        ...resetBlockTypesListRule,
+                        predicate: () => !moved && isStart && TheQueries.isBlockAboveEmpty(editor)
+                    }
+                ]
+            })(null, editor);
+            if (didReset) {
+                return;
+            }
+            /**
+             * Add a new list item if selection is in a LIST_ITEM > p.type.
+             */
+            if (!moved) {
+                const inserted = insertListItem(editor);
+                if (inserted) {
+                    return;
+                }
+            }
+        }
+        insertBreak();
+    };
+    editor.setFragmentData = unit => {
+        const { selection } = editor;
+        const [start] = Editor.edges(editor, selection);
+        if (isInList(editor, start)) {
+            const fragmentData = editor.getFragment();
+            const fragmentElement = fragmentData[0];
+            if (getListTypes().includes(fragmentElement.type)) {
+                const startNodes = getStartListItem([fragmentElement.children[0]]);
+                const children = startNodes.concat(fragmentElement.children.slice(1));
+                let fragmentNodes = [
+                    {
+                        ...fragmentElement,
+                        children
+                    }
+                ];
+                if (isSelectionInSameListItem(editor)) {
+                    // 仅仅复制列表中的内容
+                    fragmentNodes = children[0].children;
+                }
+                const fragment = fragmentNodes.concat(fragmentData.slice(1));
+                const domRange = AngularEditor.toDOMRange(editor, selection);
+                const contents = domRange.cloneContents();
+                const stringObj = JSON.stringify(fragment);
+                const encoded = window.btoa(encodeURIComponent(stringObj));
+                unit.setData(`application/${CLIPBOARD_FORMAT_KEY}`, encoded);
+                const div = document.createElement('div');
+                div.appendChild(contents);
+                div.setAttribute('hidden', 'true');
+                document.body.appendChild(div);
+                unit.setData('text/html', div.innerHTML);
+                unit.setData('text/plain', getPlainText(div));
+                document.body.removeChild(div);
+                return;
+            }
+        }
+        setFragmentData(unit);
+    };
+    editor.deleteBackward = unit => {
+        const res = getListItemEntry(editor, {});
+        if (res && isSelectionAtListItemStart(editor)) {
+            const { list, listItem } = res;
+            const [, listPath] = list;
+            const [listItemNode, listItemPath] = listItem;
+            const previousListItemPath = TheQueries.getPreviousPath(listItemPath);
+            if (previousListItemPath) {
+                const beforePoint = Editor.before(editor, listItemPath);
+                const parentPath = Path.parent(beforePoint.path);
+                const parentNode = Node.get(editor, parentPath);
+                if (Editor.isVoid(editor, parentNode)) {
+                    Editor.withoutNormalizing(editor, () => {
+                        TheTransforms.unwrapNodesByType(editor, [ElementKinds.bulletedList, ElementKinds.numberedList], {
+                            split: true
+                        });
+                        TheTransforms.unwrapNodesByType(editor, ElementKinds.listItem);
+                    });
+                    return;
+                }
+            }
+            if (previousListItemPath && hasStableListInListItem(listItemNode)) {
+                Editor.withoutNormalizing(editor, () => {
+                    deleteBackward(unit);
+                    const [previousListItemNode] = Editor.node(editor, previousListItemPath);
+                    moveListItemSublistItemsToListItemSublist(editor, {
+                        fromListItem: listItem,
+                        toListItem: [previousListItemNode, previousListItemPath],
+                        start: false
+                    }, {});
+                });
+                return;
+            }
+            // move listItem children to before listItem
+            if (listItemNode.children.length > 1) {
+                Editor.withoutNormalizing(editor, () => {
+                    const beforePathRef = Editor.pathRef(editor, listItemPath);
+                    const beforePoint = Editor.before(editor, listItemPath);
+                    const startPoint = Editor.start(editor, listItemPath);
+                    const endPoint = Editor.end(editor, listItemPath);
+                    const isInFirstChild = !isListNested(editor, listPath) && TheQueries.isFirstChild(listItemPath);
+                    const to = isInFirstChild ? listPath : Path.next(Path.parent(beforePoint.path));
+                    Transforms.moveNodes(editor, {
+                        at: Editor.range(editor, startPoint, endPoint),
+                        to,
+                        match: node => listItemNode.children.includes(node)
+                    });
+                    Transforms.delete(editor, { at: beforePathRef.unref() });
+                    if (!isInFirstChild) {
+                        deleteBackward(unit);
+                    }
+                });
+                return;
+            }
+            // deprecated
+            if (!isListNested(editor, listPath) && TheQueries.isFirstChild(listItemPath)) {
+                unwrapList(editor);
+                return;
+            }
+        }
+        deleteBackward(unit);
+    };
+    editor.insertData = (data) => {
+        const text = data.getData('text/plain');
+        const fragment = extractFragment(data);
+        const aboveEntry = Editor.above(editor, {
+            match: n => Editor.isBlock(editor, n) && n.type === ElementKinds.listItem
+        });
+        if (fragment) {
+            const res = getListItemEntry(editor, {});
+            if (fragment.length === 1 &&
+                isList(fragment[0]) &&
+                aboveEntry &&
+                !isSingleListItem(fragment[0]) &&
+                hasStableListItem(res.listItem[0])) {
+                insertListData(editor, { fromList: fragment[0], toListItemEntry: aboveEntry });
+                return;
+            }
+        }
+        insertData(data);
+    };
+    editor.onKeydown = (event) => {
+        const isContinue = !onKeyDownList(event, editor);
+        if (isContinue) {
+            onKeydown(event);
+        }
+    };
+    editor.normalizeNode = getListNormalizer(editor, { validLiChildrenTypes: validLiChildrenTypes });
+    editor.renderElement = (element) => {
+        if (element.type === ElementKinds.numberedList) {
+            return TheNumberedListComponent;
+        }
+        if (element.type === ElementKinds.bulletedList) {
+            return TheBulletedListComponent;
+        }
+        if (element.type === ElementKinds.listItem) {
+            return TheListItemComponent;
+        }
+        return renderElement(element);
+    };
+    return editor;
+};
+const listOptions = {
+    validLiChildrenTypes: [ElementKinds.image],
+    allowParentTypes: [ElementKinds.listItem, ElementKinds.tableCell, ElementKinds.blockquote]
+};
+export const createListPlugin = createPluginFactory({
+    key: PluginKeys.list,
+    withOverrides: withList,
+    plugins: [
+        {
+            key: PluginKeys.numberedList,
+            options: listOptions
+        },
+        {
+            key: PluginKeys.bulletedList,
+            options: listOptions
+        }
+    ],
+    nestedStructureByKey: {
+        [ElementKinds.bulletedList]: ElementKinds.listItem,
+        [ElementKinds.numberedList]: ElementKinds.listItem
+    },
+    toolbarItems: [
+        {
+            key: ElementKinds.numberedList,
+            icon: 'list-ordered',
+            name: '有序列表',
+            execute: editor => ListEditor.toggleList(editor, ElementKinds.numberedList),
+            active: editor => ListEditor.isActive(editor, ElementKinds.numberedList)
+        },
+        {
+            key: ElementKinds.bulletedList,
+            icon: 'list-bullet',
+            name: '无序列表',
+            execute: editor => ListEditor.toggleList(editor, ElementKinds.bulletedList),
+            active: editor => ListEditor.isActive(editor, ElementKinds.bulletedList)
+        }
+    ],
+    options: listOptions
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.plugin.js","sourceRoot":"","sources":["../../../../../packages/src/plugins/list/list.plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import { Transforms, Node, Editor, Path, Ancestor, Element } from 'slate';\nimport { AngularEditor, getPlainText } from 'slate-angular';\nimport { CLIPBOARD_FORMAT_KEY, ElementKinds } from '../../constants';\nimport * as TheQueries from '../../queries';\nimport * as TheTransforms from '../../transforms';\nimport { isList } from './queries/is-list';\nimport { isInList } from './queries/is-in-list';\nimport { isListNested } from './queries/is-list-nested';\nimport { getListTypes } from './queries/get-list-types';\nimport { getStartListItem } from './queries/get-start-list-item';\nimport { isSingleListItem } from './queries/is-single-list-item';\nimport { getListItemEntry } from './queries/get-list-item-entry';\nimport { hasListInListItem, hasStableListInListItem, hasStableListItem } from './queries/has-list-in-list-item';\nimport { isSelectionAtListItemStart } from './queries/is-selection-at-list-item-start';\nimport { insertListData } from './transforms/insert-list-data';\nimport { moveListItemUp } from './transforms/move-list-item-up';\nimport { insertListItem } from './transforms/insert-list-item';\nimport { unwrapList } from './transforms/unwrap-list';\nimport { moveListItemSublistItemsToListItemSublist } from './transforms/move-list-item-sublist-items-to-list-item-sublist';\nimport { getListNormalizer } from './normalizers/get-list-normalizer';\nimport { onKeyDownList } from './on-key-down-list';\nimport { WithListOptions } from './types';\nimport { TheNumberedListComponent } from './components/numbered-list.component';\nimport { TheBulletedListComponent } from './components/bulleted-list.component';\nimport { TheListItemComponent } from './components/list-item.component';\nimport { extractFragment } from '../../utils/fragment';\nimport { isSelectionInSameListItem } from './queries/is-selection-in-same-list-item';\nimport { createPluginFactory, getPluginOptions } from '../../core';\nimport { PluginKeys } from '../../interfaces';\nimport { ListEditor } from './list.editor';\n\nexport const withList = <T extends Editor>(editor: T): T => {\n    const { insertBreak, deleteBackward, onKeydown, insertData, setFragmentData, renderElement } = editor;\n\n    const validLiChildrenTypes = getPluginOptions<WithListOptions>(editor, PluginKeys.list)?.validLiChildrenTypes ?? [];\n\n    const resetBlockTypesListRule = {\n        types: [ElementKinds.listItem],\n        defaultType: ElementKinds.paragraph,\n        onReset: (_editor: Editor) => unwrapList(_editor)\n    };\n\n    editor.insertBreak = () => {\n        const node = TheQueries.anchorBlock(editor);\n\n        if (!node) {\n            insertBreak();\n            return;\n        }\n\n        const isVoid = Editor.isVoid(editor, node);\n        if (isVoid) {\n            insertBreak();\n            return;\n        }\n        const listEntry = getListItemEntry(editor, {});\n        if (listEntry) {\n            let moved: boolean | undefined;\n            const { list, listItem } = listEntry;\n            const [listItemNode, listItemPath] = listItem;\n            const cursor = editor.selection.focus;\n            const isStart = Editor.isStart(editor, cursor, listItemPath);\n\n            // deprecated\n            // 如果有子级\n            if (hasListInListItem(listItemNode)) {\n                /**\n                 * If selection is at the end of li,\n                 * insert below li where children will be moved.\n                 */\n                if (Editor.isEnd(editor, cursor, listItemPath)) {\n                    return Transforms.insertNodes(\n                        editor,\n                        {\n                            type: ElementKinds.listItem,\n                            children: [{ type: ElementKinds.paragraph, children: [{ text: '' }] }]\n                        },\n                        { at: Path.next(listItemPath), select: true }\n                    );\n                }\n\n                /**\n                 * 如果选区是在listItem的开头，则在listItem上方插入\n                 */\n                if (isStart) {\n                    return Transforms.insertNodes(\n                        editor,\n                        {\n                            type: ElementKinds.listItem,\n                            children: [{ type: ElementKinds.paragraph, children: [{ text: '' }] }]\n                        },\n                        { at: listItemPath }\n                    );\n                }\n            }\n\n            // 如果选择的listItem为空则将其向上移动\n            if (isStart && TheQueries.isBlockAboveEmpty(editor)) {\n                moved = moveListItemUp(editor, { list, listItem });\n                if (moved) return;\n            }\n\n            const didReset = TheTransforms.onKeyDownResetBlockType({\n                rules: [\n                    {\n                        ...resetBlockTypesListRule,\n                        predicate: () => !moved && isStart && TheQueries.isBlockAboveEmpty(editor)\n                    }\n                ]\n            })(null, editor);\n            if (didReset) {\n                return;\n            }\n\n            /**\n             * Add a new list item if selection is in a LIST_ITEM > p.type.\n             */\n            if (!moved) {\n                const inserted = insertListItem(editor);\n                if (inserted) {\n                    return;\n                }\n            }\n        }\n\n        insertBreak();\n    };\n\n    editor.setFragmentData = unit => {\n        const { selection } = editor;\n        const [start] = Editor.edges(editor, selection);\n        if (isInList(editor, start)) {\n            const fragmentData = editor.getFragment();\n            const fragmentElement = fragmentData[0] as Element;\n            if (getListTypes().includes(fragmentElement.type)) {\n                const startNodes = getStartListItem([fragmentElement.children[0]] as Element[]);\n                const children = startNodes.concat((fragmentElement.children as Element[]).slice(1));\n                let fragmentNodes = [\n                    {\n                        ...fragmentElement,\n                        children\n                    }\n                ] as Node[];\n                if (isSelectionInSameListItem(editor)) {\n                    // 仅仅复制列表中的内容\n                    fragmentNodes = children[0].children;\n                }\n                const fragment = fragmentNodes.concat(fragmentData.slice(1));\n                const domRange = AngularEditor.toDOMRange(editor, selection);\n                const contents = domRange.cloneContents();\n                const stringObj = JSON.stringify(fragment);\n                const encoded = window.btoa(encodeURIComponent(stringObj));\n                unit.setData(`application/${CLIPBOARD_FORMAT_KEY}`, encoded);\n                const div = document.createElement('div');\n                div.appendChild(contents);\n                div.setAttribute('hidden', 'true');\n                document.body.appendChild(div);\n                unit.setData('text/html', div.innerHTML);\n                unit.setData('text/plain', getPlainText(div));\n                document.body.removeChild(div);\n                return;\n            }\n        }\n        setFragmentData(unit);\n    };\n\n    editor.deleteBackward = unit => {\n        const res = getListItemEntry(editor, {});\n\n        if (res && isSelectionAtListItemStart(editor)) {\n            const { list, listItem } = res;\n            const [, listPath] = list;\n            const [listItemNode, listItemPath] = listItem;\n\n            const previousListItemPath = TheQueries.getPreviousPath(listItemPath);\n\n            if (previousListItemPath) {\n                const beforePoint = Editor.before(editor, listItemPath);\n                const parentPath = Path.parent(beforePoint.path);\n                const parentNode = Node.get(editor, parentPath);\n                if (Editor.isVoid(editor, parentNode)) {\n                    Editor.withoutNormalizing(editor, () => {\n                        TheTransforms.unwrapNodesByType(editor, [ElementKinds.bulletedList, ElementKinds.numberedList], {\n                            split: true\n                        });\n                        TheTransforms.unwrapNodesByType(editor, ElementKinds.listItem);\n                    });\n                    return;\n                }\n            }\n\n            if (previousListItemPath && hasStableListInListItem(listItemNode)) {\n                Editor.withoutNormalizing(editor, () => {\n                    deleteBackward(unit);\n                    const [previousListItemNode] = Editor.node(editor, previousListItemPath);\n                    moveListItemSublistItemsToListItemSublist(\n                        editor,\n                        {\n                            fromListItem: listItem,\n                            toListItem: [previousListItemNode as Ancestor, previousListItemPath],\n                            start: false\n                        },\n                        {}\n                    );\n                });\n                return;\n            }\n\n            // move listItem children to before listItem\n            if (listItemNode.children.length > 1) {\n                Editor.withoutNormalizing(editor, () => {\n                    const beforePathRef = Editor.pathRef(editor, listItemPath);\n                    const beforePoint = Editor.before(editor, listItemPath);\n                    const startPoint = Editor.start(editor, listItemPath);\n                    const endPoint = Editor.end(editor, listItemPath);\n                    const isInFirstChild = !isListNested(editor, listPath) && TheQueries.isFirstChild(listItemPath);\n                    const to = isInFirstChild ? listPath : Path.next(Path.parent(beforePoint.path));\n\n                    Transforms.moveNodes(editor, {\n                        at: Editor.range(editor, startPoint, endPoint),\n                        to,\n                        match: node => listItemNode.children.includes(node as any)\n                    });\n                    Transforms.delete(editor, { at: beforePathRef.unref() });\n\n                    if (!isInFirstChild) {\n                        deleteBackward(unit);\n                    }\n                });\n                return;\n            }\n\n            // deprecated\n            if (!isListNested(editor, listPath) && TheQueries.isFirstChild(listItemPath)) {\n                unwrapList(editor);\n                return;\n            }\n        }\n\n        deleteBackward(unit);\n    };\n\n    editor.insertData = (data: DataTransfer) => {\n        const text = data.getData('text/plain');\n        const fragment = extractFragment(data);\n        const aboveEntry = Editor.above(editor, {\n            match: n => Editor.isBlock(editor, n) && n.type === ElementKinds.listItem\n        });\n        if (fragment) {\n            const res = getListItemEntry(editor, {});\n            if (\n                fragment.length === 1 &&\n                isList(fragment[0] as Element) &&\n                aboveEntry &&\n                !isSingleListItem(fragment[0]) &&\n                hasStableListItem(res.listItem[0])\n            ) {\n                insertListData(editor, { fromList: fragment[0] as Element, toListItemEntry: aboveEntry });\n                return;\n            }\n        }\n\n        insertData(data);\n    };\n\n    editor.onKeydown = (event: KeyboardEvent) => {\n        const isContinue = !onKeyDownList(event, editor);\n        if (isContinue) {\n            onKeydown(event);\n        }\n    };\n\n    editor.normalizeNode = getListNormalizer(editor, { validLiChildrenTypes: validLiChildrenTypes });\n\n    editor.renderElement = (element: Element) => {\n        if (element.type === ElementKinds.numberedList) {\n            return TheNumberedListComponent;\n        }\n        if (element.type === ElementKinds.bulletedList) {\n            return TheBulletedListComponent;\n        }\n        if (element.type === ElementKinds.listItem) {\n            return TheListItemComponent;\n        }\n        return renderElement(element);\n    };\n\n    return editor;\n};\n\nconst listOptions = {\n    validLiChildrenTypes: [ElementKinds.image],\n    allowParentTypes: [ElementKinds.listItem, ElementKinds.tableCell, ElementKinds.blockquote]\n};\n\nexport const createListPlugin = createPluginFactory<WithListOptions>({\n    key: PluginKeys.list,\n    withOverrides: withList,\n    plugins: [\n        {\n            key: PluginKeys.numberedList,\n            options: listOptions\n        },\n        {\n            key: PluginKeys.bulletedList,\n            options: listOptions\n        }\n    ],\n    nestedStructureByKey: {\n        [ElementKinds.bulletedList]: ElementKinds.listItem,\n        [ElementKinds.numberedList]: ElementKinds.listItem\n    },\n    toolbarItems: [\n        {\n            key: ElementKinds.numberedList,\n            icon: 'list-ordered',\n            name: '有序列表',\n            execute: editor => ListEditor.toggleList(editor, ElementKinds.numberedList),\n            active: editor => ListEditor.isActive(editor, ElementKinds.numberedList)\n        },\n        {\n            key: ElementKinds.bulletedList,\n            icon: 'list-bullet',\n            name: '无序列表',\n            execute: editor => ListEditor.toggleList(editor, ElementKinds.bulletedList),\n            active: editor => ListEditor.isActive(editor, ElementKinds.bulletedList)\n        }\n    ],\n    options: listOptions\n});\n"]}

package/{esm2015/plugins/list/normalizers/get-list-normalizer.js → esm2020/plugins/list/normalizers/get-list-normalizer.mjs}

@@ -1,39 +1,39 @@
-import { Transforms, Element } from 'slate';
-import { ElementKinds } from '../../../constants';
-import { match } from '../../../utils/match';
-import { getListTypes } from '../queries/get-list-types';
-import { normalizeListItem } from './normalize-list-item';
-import { normalizeNo } from './normalize-no';
-import { isList } from '../queries/is-list';
-import { TheHistoryEditor } from '../../common/history.plugin';
-/**
- * Normalize list node to force the ul>li>p+ul structure.
- */
-export const getListNormalizer = (editor, { validLiChildrenTypes }) => {
-    const { normalizeNode } = editor;
-    return ([node, path]) => {
-        // 不是选区, 执行续号检测操作
-        if (isList(node) && !TheHistoryEditor.isUndoing(editor)) {
-            const moved = normalizeNo(editor, [node, path]);
-            if (moved) {
-                return;
-            }
-        }
-        if (match(node, { type: getListTypes() })) {
-            if (Element.isElement(node) && !node.children.length) {
-                return Transforms.removeNodes(editor, { at: path });
-            }
-        }
-        // normalize list item
-        // 1. list-item at least one child
-        // 2. list-item first child is not list
-        if (Element.isElement(node) && node.type === ElementKinds.listItem) {
-            if (normalizeListItem(editor, { nodeEntry: [node, path] })) {
-                // Tree changed - kick off another normalization
-                return;
-            }
-        }
-        normalizeNode([node, path]);
-    };
-};
-//# sourceMappingURL=data:application/json;base64,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
+import { Transforms, Element } from 'slate';
+import { ElementKinds } from '../../../constants';
+import { match } from '../../../utils/match';
+import { getListTypes } from '../queries/get-list-types';
+import { normalizeListItem } from './normalize-list-item';
+import { normalizeNo } from './normalize-no';
+import { isList } from '../queries/is-list';
+import { TheHistoryEditor } from '../../common/history.plugin';
+/**
+ * Normalize list node to force the ul>li>p+ul structure.
+ */
+export const getListNormalizer = (editor, { validLiChildrenTypes }) => {
+    const { normalizeNode } = editor;
+    return ([node, path]) => {
+        // 不是选区, 执行续号检测操作
+        if (isList(node) && !TheHistoryEditor.isUndoing(editor)) {
+            const moved = normalizeNo(editor, [node, path]);
+            if (moved) {
+                return;
+            }
+        }
+        if (match(node, { type: getListTypes() })) {
+            if (Element.isElement(node) && !node.children.length) {
+                return Transforms.removeNodes(editor, { at: path });
+            }
+        }
+        // normalize list item
+        // 1. list-item at least one child
+        // 2. list-item first child is not list
+        if (Element.isElement(node) && node.type === ElementKinds.listItem) {
+            if (normalizeListItem(editor, { nodeEntry: [node, path] })) {
+                // Tree changed - kick off another normalization
+                return;
+            }
+        }
+        normalizeNode([node, path]);
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/plugins/list/normalizers/normalize-list-item.mjs

@@ -0,0 +1,18 @@
+import { Element } from 'slate';
+import { ElementKinds } from '../../../constants';
+import { insertParagraph } from '../../../transforms/insert-paragraph';
+export const normalizeListItem = (editor, { nodeEntry }) => {
+    const [listItemNode, listItemPath] = nodeEntry;
+    const firstChildPath = listItemPath.concat([0]);
+    const firstChild = listItemNode.children?.[0];
+    if (!firstChild) {
+        insertParagraph(editor, firstChildPath);
+        return true;
+    }
+    // Ensure that all lists have a <p> tag as a first element
+    if (Element.isElement(firstChild) && (firstChild.type === ElementKinds.bulletedList || firstChild.type === ElementKinds.numberedList)) {
+        insertParagraph(editor, firstChildPath);
+        return true;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/plugins/list/normalizers/normalize-no.js → esm2020/plugins/list/normalizers/normalize-no.mjs}

@@ -1,43 +1,43 @@
-import { Editor, Transforms, Path, Element } from 'slate';
-import * as TheQueries from '../../../queries';
-import * as TheTransforms from '../../../transforms';
-// 列表续号
-export const normalizeNo = (editor, nodeEntry) => {
-    const [listNode, listPath] = nodeEntry;
-    let moved = false;
-    Editor.withoutNormalizing(editor, () => {
-        /**
-         * 获取nextList判断是否为同类型list
-         * 如果为同类型list，则把nextList children移动到当前list的尾部, 并删除nextList
-         */
-        const nextPath = Path.next(listPath);
-        const nextNode = TheQueries.getNode(editor, nextPath);
-        if (nextNode && Element.isElement(nextNode) && Element.isElement(listNode) && nextNode.type === listNode.type) {
-            TheTransforms.moveChildren(editor, {
-                at: [nextNode, nextPath],
-                to: listPath.concat(listNode.children.length)
-            });
-            Transforms.removeNodes(editor, { at: nextPath });
-            moved = true;
-        }
-        if (listPath[listPath.length - 1] !== 0) {
-            /**
-             * 获取prevList判断是否为同类型list
-             * 如果为同类型list，则把当前list children移动到prevList的尾部, 并删除当前List
-             */
-            const currentListNode = TheQueries.getNode(editor, listPath);
-            const prevPath = Path.previous(listPath);
-            const prevNode = TheQueries.getNode(editor, prevPath);
-            if (prevNode && Element.isElement(prevNode) && Element.isElement(currentListNode) && prevNode.type === currentListNode.type) {
-                TheTransforms.moveChildren(editor, {
-                    at: [currentListNode, listPath],
-                    to: prevPath.concat(prevNode.children.length)
-                });
-                Transforms.removeNodes(editor, { at: listPath });
-                moved = true;
-            }
-        }
-    });
-    return moved;
-};
+import { Editor, Transforms, Path, Element } from 'slate';
+import * as TheQueries from '../../../queries';
+import * as TheTransforms from '../../../transforms';
+// 列表续号
+export const normalizeNo = (editor, nodeEntry) => {
+    const [listNode, listPath] = nodeEntry;
+    let moved = false;
+    Editor.withoutNormalizing(editor, () => {
+        /**
+         * 获取nextList判断是否为同类型list
+         * 如果为同类型list，则把nextList children移动到当前list的尾部, 并删除nextList
+         */
+        const nextPath = Path.next(listPath);
+        const nextNode = TheQueries.getNode(editor, nextPath);
+        if (nextNode && Element.isElement(nextNode) && Element.isElement(listNode) && nextNode.type === listNode.type) {
+            TheTransforms.moveChildren(editor, {
+                at: [nextNode, nextPath],
+                to: listPath.concat(listNode.children.length)
+            });
+            Transforms.removeNodes(editor, { at: nextPath });
+            moved = true;
+        }
+        if (listPath[listPath.length - 1] !== 0) {
+            /**
+             * 获取prevList判断是否为同类型list
+             * 如果为同类型list，则把当前list children移动到prevList的尾部, 并删除当前List
+             */
+            const currentListNode = TheQueries.getNode(editor, listPath);
+            const prevPath = Path.previous(listPath);
+            const prevNode = TheQueries.getNode(editor, prevPath);
+            if (prevNode && Element.isElement(prevNode) && Element.isElement(currentListNode) && prevNode.type === currentListNode.type) {
+                TheTransforms.moveChildren(editor, {
+                    at: [currentListNode, listPath],
+                    to: prevPath.concat(prevNode.children.length)
+                });
+                Transforms.removeNodes(editor, { at: listPath });
+                moved = true;
+            }
+        }
+    });
+    return moved;
+};
 //# sourceMappingURL=data:application/json;base64,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

package/{esm2015/plugins/list/on-key-down-list.js → esm2020/plugins/list/on-key-down-list.mjs}

@@ -1,33 +1,33 @@
-import { moveListItemUp } from './transforms/move-list-item-up';
-import { moveListItemDown } from './transforms/move-list-item-down';
-import { getListItemEntry } from './queries/get-list-item-entry';
-import * as TheQueries from '../../queries';
-export function onKeyDownList(e, editor) {
-    let moved = false;
-    if (e.key === 'Tab') {
-        const res = getListItemEntry(editor, {});
-        if (!res) {
-            return false;
-        }
-        const { list, listItem } = res;
-        const [, listItemPath] = listItem;
-        e.preventDefault();
-        // move up with shift+tab
-        const shiftTab = e.shiftKey;
-        if (shiftTab) {
-            moved = moveListItemUp(editor, { list, listItem });
-            if (moved) {
-                e.preventDefault();
-                return true;
-            }
-        }
-        // move down with tab
-        const tab = !e.shiftKey;
-        if (tab && !TheQueries.isFirstChild(listItemPath)) {
-            moveListItemDown(editor, { list, listItem });
-            return true;
-        }
-        return false;
-    }
-}
+import { moveListItemUp } from './transforms/move-list-item-up';
+import { moveListItemDown } from './transforms/move-list-item-down';
+import { getListItemEntry } from './queries/get-list-item-entry';
+import * as TheQueries from '../../queries';
+export function onKeyDownList(e, editor) {
+    let moved = false;
+    if (e.key === 'Tab') {
+        const res = getListItemEntry(editor, {});
+        if (!res) {
+            return false;
+        }
+        const { list, listItem } = res;
+        const [, listItemPath] = listItem;
+        e.preventDefault();
+        // move up with shift+tab
+        const shiftTab = e.shiftKey;
+        if (shiftTab) {
+            moved = moveListItemUp(editor, { list, listItem });
+            if (moved) {
+                e.preventDefault();
+                return true;
+            }
+        }
+        // move down with tab
+        const tab = !e.shiftKey;
+        if (tab && !TheQueries.isFirstChild(listItemPath)) {
+            moveListItemDown(editor, { list, listItem });
+            return true;
+        }
+        return false;
+    }
+}
 //# sourceMappingURL=data:application/json;base64,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