@worktile/theia 15.3.2 → 16.0.0

package/esm2022/plugins/list/list.editor.mjs

@@ -0,0 +1,126 @@
+import { Transforms, Node, Editor, Path, Element } from 'slate';
+import { ElementKinds, LIST_BLOCK_TYPES } from '../../constants/node-types';
+import { isNodeTypeList } from './queries/is-node-type-list';
+import * as TheQueries from '../../queries';
+import * as TheTransforms from '../../transforms';
+export const ListEditor = {
+    isList(editor, element, type) {
+        return Editor.isBlock(editor, element) && element.type === type;
+    },
+    toggleList(editor, type, startIndex) {
+        if (!editor.selection) {
+            return;
+        }
+        if (!startIndex) {
+            startIndex = 1;
+        }
+        const types = [ElementKinds.bulletedList, ElementKinds.numberedList];
+        Editor.withoutNormalizing(editor, () => {
+            const [...listItems] = Editor.nodes(editor, {
+                match: (n) => Element.isElement(n) && n.type === ElementKinds.listItem,
+                mode: 'lowest'
+            });
+            const firstListItemPath = listItems.length && listItems[0][1];
+            const activeListPath = listItems.length && Path.parent(firstListItemPath);
+            const activeListNode = listItems.length && Node.get(editor, activeListPath);
+            // 同级且类型相同：unwrap
+            const isLowestActive = listItems.length &&
+                listItems.every(([, path]) => activeListNode.type === type && (Path.isSibling(firstListItemPath, path) || Path.equals(firstListItemPath, path)));
+            if (isLowestActive) {
+                const upListItem = Path.parent(activeListPath);
+                Transforms.unwrapNodes(editor, {
+                    at: editor.selection,
+                    match: node => node === activeListNode,
+                    split: true,
+                    mode: 'lowest'
+                });
+                if (upListItem && Node.get(editor, upListItem).type === ElementKinds.listItem) {
+                    Transforms.moveNodes(editor, {
+                        at: editor.selection,
+                        to: Path.next(upListItem),
+                        match: (n) => Element.isElement(n) && n.type === ElementKinds.listItem
+                    });
+                }
+                else {
+                    Transforms.unwrapNodes(editor, {
+                        match: (n) => Element.isElement(n) && n.type === ElementKinds.listItem
+                    });
+                }
+                return;
+            }
+            // 跨级、同级且类型不同
+            if (activeListNode && types.includes(activeListNode.type)) {
+                Transforms.setNodes(editor, { type }, { match: (n) => Element.isElement(n) && n.type !== type && types.includes(n.type) });
+                return;
+            }
+            // wrap
+            ListEditor.buildListItem(editor);
+            Transforms.wrapNodes(editor, { type, children: [], start: startIndex }, {
+                at: editor.selection,
+                match: (n) => Element.isElement(n) && n.type === ElementKinds.listItem
+            });
+        });
+    },
+    unwrapList(editor) {
+        Editor.withoutNormalizing(editor, () => {
+            TheTransforms.unwrapNodesByType(editor, [ElementKinds.bulletedList, ElementKinds.numberedList], { split: true, mode: 'all' });
+            TheTransforms.unwrapNodesByType(editor, [ElementKinds.listItem], { split: true, mode: 'all' });
+        });
+    },
+    wrapList(editor, type) {
+        Editor.withoutNormalizing(editor, () => {
+            const listItem = {
+                type: ElementKinds.listItem,
+                children: []
+            };
+            const list = {
+                type,
+                children: []
+            };
+            Transforms.wrapNodes(editor, list, { split: true });
+            Transforms.wrapNodes(editor, listItem, { split: true });
+        });
+    },
+    isActive(editor, type) {
+        const [match] = TheQueries.getNodesByType(editor, type);
+        return !!match;
+    },
+    getActiveList(editor) {
+        const [match] = TheQueries.getNodesByType(editor, LIST_BLOCK_TYPES);
+        return match;
+    },
+    buildListItem(editor) {
+        const nodes = Editor.nodes(editor, {
+            match: (n) => Editor.isBlock(editor, n),
+            mode: 'lowest'
+        });
+        for (const [node, path] of nodes) {
+            if (!Editor.isVoid(editor, node) && Element.isElement(node) && node.type !== ElementKinds.paragraph) {
+                Transforms.setNodes(editor, { type: ElementKinds.paragraph, checked: undefined }, // todo remove checked
+                { at: path });
+            }
+            else if (Element.isElement(node) && node.type === ElementKinds.paragraph) {
+                let { textIndent } = node;
+                if (textIndent) {
+                    Transforms.setNodes(editor, { textIndent: undefined, indent: undefined }, // remove indent
+                    { at: path });
+                }
+            }
+            if (Node.parent(editor, path).type !== ElementKinds.listItem) {
+                Transforms.wrapNodes(editor, { type: ElementKinds.listItem, children: [] }, {
+                    at: path,
+                    split: true
+                });
+            }
+        }
+    },
+    buildInsertDataChildren(node) {
+        const { children } = node;
+        const listItem = children[0];
+        if (isNodeTypeList(node) && Element.isElement(listItem) && listItem.children[0].type === ElementKinds.paragraph) {
+            return node;
+        }
+        return ListEditor.buildInsertDataChildren(listItem);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.editor.js","sourceRoot":"","sources":["../../../../../packages/src/plugins/list/list.editor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAE5E,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AAElD,MAAM,CAAC,MAAM,UAAU,GAAG;IACtB,MAAM,CAAC,MAAiB,EAAE,OAAsB,EAAE,IAA2D;QACzG,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,CAAC;IACpE,CAAC;IACD,UAAU,CAAC,MAAiB,EAAE,IAA2D,EAAE,UAAmB;QAC1G,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE;YACnB,OAAO;SACV;QACD,IAAI,CAAC,UAAU,EAAE;YACb,UAAU,GAAG,CAAC,CAAC;SAClB;QACD,MAAM,KAAK,GAAG,CAAC,YAAY,CAAC,YAAY,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC;QAErE,MAAM,CAAC,kBAAkB,CAAC,MAAM,EAAE,GAAG,EAAE;YACnC,MAAM,CAAC,GAAG,SAAS,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE;gBACxC,KAAK,EAAE,CAAC,CAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,YAAY,CAAC,QAAQ;gBACrF,IAAI,EAAE,QAAQ;aACjB,CAAC,CAAC;YACH,MAAM,iBAAiB,GAAG,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC9D,MAAM,cAAc,GAAG,SAAS,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;YAC1E,MAAM,cAAc,GAAG,SAAS,CAAC,MAAM,IAAK,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,CAAmB,CAAC;YAE/F,iBAAiB;YACjB,MAAM,cAAc,GAChB,SAAS,CAAC,MAAM;gBAChB,SAAS,CAAC,KAAK,CACX,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE,CACT,cAAc,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC,CACxH,CAAC;YACN,IAAI,cAAc,EAAE;gBAChB,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;gBAC/C,UAAU,CAAC,WAAW,CAAC,MAAM,EAAE;oBAC3B,EAAE,EAAE,MAAM,CAAC,SAAS;oBACpB,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,cAAc;oBACtC,KAAK,EAAE,IAAI;oBACX,IAAI,EAAE,QAAQ;iBACjB,CAAC,CAAC;gBACH,IAAI,UAAU,IAAK,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAmB,CAAC,IAAI,KAAK,YAAY,CAAC,QAAQ,EAAE;oBAC9F,UAAU,CAAC,SAAS,CAAC,MAAM,EAAE;wBACzB,EAAE,EAAE,MAAM,CAAC,SAAS;wBACpB,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC;wBACzB,KAAK,EAAE,CAAC,CAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,YAAY,CAAC,QAAQ;qBACxF,CAAC,CAAC;iBACN;qBAAM;oBACH,UAAU,CAAC,WAAW,CAAC,MAAM,EAAE;wBAC3B,KAAK,EAAE,CAAC,CAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,YAAY,CAAC,QAAQ;qBACxF,CAAC,CAAC;iBACN;gBACD,OAAO;aACV;YAED,aAAa;YACb,IAAI,cAAc,IAAI,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE;gBACvD,UAAU,CAAC,QAAQ,CACf,MAAM,EACN,EAAE,IAAI,EAAmB,EACzB,EAAE,KAAK,EAAE,CAAC,CAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,IAAI,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CACrG,CAAC;gBACF,OAAO;aACV;YAED,OAAO;YACP,UAAU,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YACjC,UAAU,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,UAAU,EAAmB,EAAE;gBACrF,EAAE,EAAE,MAAM,CAAC,SAAS;gBACpB,KAAK,EAAE,CAAC,CAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,YAAY,CAAC,QAAQ;aACxF,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACP,CAAC;IACD,UAAU,CAAC,MAAiB;QACxB,MAAM,CAAC,kBAAkB,CAAC,MAAM,EAAE,GAAG,EAAE;YACnC,aAAa,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,YAAY,CAAC,YAAY,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;YAC9H,aAAa,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACnG,CAAC,CAAC,CAAC;IACP,CAAC;IACD,QAAQ,CAAC,MAAiB,EAAE,IAA2D;QACnF,MAAM,CAAC,kBAAkB,CAAC,MAAM,EAAE,GAAG,EAAE;YACnC,MAAM,QAAQ,GAAkB;gBAC5B,IAAI,EAAE,YAAY,CAAC,QAAQ;gBAC3B,QAAQ,EAAE,EAAE;aACf,CAAC;YACF,MAAM,IAAI,GAAG;gBACT,IAAI;gBACJ,QAAQ,EAAE,EAAE;aACf,CAAC;YACF,UAAU,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;YACpD,UAAU,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5D,CAAC,CAAC,CAAC;IACP,CAAC;IACD,QAAQ,CAAC,MAAiB,EAAE,IAA2D;QACnF,MAAM,CAAC,KAAK,CAAC,GAAG,UAAU,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACxD,OAAO,CAAC,CAAC,KAAK,CAAC;IACnB,CAAC;IACD,aAAa,CAAC,MAAiB;QAC3B,MAAM,CAAC,KAAK,CAAC,GAAG,UAAU,CAAC,cAAc,CAAC,MAAM,EAAE,gBAA4B,CAAC,CAAC;QAChF,OAAO,KAAK,CAAC;IACjB,CAAC;IACD,aAAa,CAAC,MAAiB;QAC3B,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE;YAC/B,KAAK,EAAE,CAAC,CAAgB,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;YACtD,IAAI,EAAE,QAAQ;SACjB,CAAC,CAAC;QACH,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,KAAK,EAAE;YAC9B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,IAAK,IAAY,CAAC,IAAI,KAAK,YAAY,CAAC,SAAS,EAAE;gBAC1G,UAAU,CAAC,QAAQ,CACf,MAAM,EACN,EAAE,IAAI,EAAE,YAAY,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,EAAS,EAAE,sBAAsB;gBACnF,EAAE,EAAE,EAAE,IAAI,EAAE,CACf,CAAC;aACL;iBAAM,IAAI,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,IAAK,IAAsB,CAAC,IAAI,KAAK,YAAY,CAAC,SAAS,EAAE;gBAC3F,IAAI,EAAE,UAAU,EAAE,GAAG,IAAqB,CAAC;gBAC3C,IAAI,UAAU,EAAE;oBACZ,UAAU,CAAC,QAAQ,CACf,MAAM,EACN,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAmB,EAAE,gBAAgB;oBAC/E,EAAE,EAAE,EAAE,IAAI,EAAE,CACf,CAAC;iBACL;aACJ;YACD,IAAK,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAmB,CAAC,IAAI,KAAK,YAAY,CAAC,QAAQ,EAAE;gBAC7E,UAAU,CAAC,SAAS,CAChB,MAAM,EACN,EAAE,IAAI,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAmB,EAC9D;oBACI,EAAE,EAAE,IAAI;oBACR,KAAK,EAAE,IAAI;iBACd,CACJ,CAAC;aACL;SACJ;IACL,CAAC;IACD,uBAAuB,CAAC,IAAmB;QACvC,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;QAC1B,MAAM,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QAC7B,IAAI,cAAc,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAK,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAmB,CAAC,IAAI,KAAK,YAAY,CAAC,SAAS,EAAE;YAChI,OAAO,IAAI,CAAC;SACf;QAED,OAAO,UAAU,CAAC,uBAAuB,CAAC,QAAyB,CAAC,CAAC;IACzE,CAAC;CACJ,CAAC","sourcesContent":["import { Transforms, Node, Editor, Path, Element } from 'slate';\nimport { ElementKinds, LIST_BLOCK_TYPES } from '../../constants/node-types';\nimport { CustomElement } from '../../custom-types';\nimport { isNodeTypeList } from './queries/is-node-type-list';\nimport { TheEditor } from '../../interfaces';\nimport * as TheQueries from '../../queries';\nimport * as TheTransforms from '../../transforms';\n\nexport const ListEditor = {\n    isList(editor: TheEditor, element: CustomElement, type: ElementKinds.bulletedList | ElementKinds.numberedList) {\n        return Editor.isBlock(editor, element) && element.type === type;\n    },\n    toggleList(editor: TheEditor, type: ElementKinds.bulletedList | ElementKinds.numberedList, startIndex?: number) {\n        if (!editor.selection) {\n            return;\n        }\n        if (!startIndex) {\n            startIndex = 1;\n        }\n        const types = [ElementKinds.bulletedList, ElementKinds.numberedList];\n\n        Editor.withoutNormalizing(editor, () => {\n            const [...listItems] = Editor.nodes(editor, {\n                match: (n: CustomElement) => Element.isElement(n) && n.type === ElementKinds.listItem,\n                mode: 'lowest'\n            });\n            const firstListItemPath = listItems.length && listItems[0][1];\n            const activeListPath = listItems.length && Path.parent(firstListItemPath);\n            const activeListNode = listItems.length && (Node.get(editor, activeListPath) as CustomElement);\n\n            // 同级且类型相同：unwrap\n            const isLowestActive =\n                listItems.length &&\n                listItems.every(\n                    ([, path]) =>\n                        activeListNode.type === type && (Path.isSibling(firstListItemPath, path) || Path.equals(firstListItemPath, path))\n                );\n            if (isLowestActive) {\n                const upListItem = Path.parent(activeListPath);\n                Transforms.unwrapNodes(editor, {\n                    at: editor.selection,\n                    match: node => node === activeListNode,\n                    split: true,\n                    mode: 'lowest'\n                });\n                if (upListItem && (Node.get(editor, upListItem) as CustomElement).type === ElementKinds.listItem) {\n                    Transforms.moveNodes(editor, {\n                        at: editor.selection,\n                        to: Path.next(upListItem),\n                        match: (n: CustomElement) => Element.isElement(n) && n.type === ElementKinds.listItem\n                    });\n                } else {\n                    Transforms.unwrapNodes(editor, {\n                        match: (n: CustomElement) => Element.isElement(n) && n.type === ElementKinds.listItem\n                    });\n                }\n                return;\n            }\n\n            // 跨级、同级且类型不同\n            if (activeListNode && types.includes(activeListNode.type)) {\n                Transforms.setNodes(\n                    editor,\n                    { type } as CustomElement,\n                    { match: (n: CustomElement) => Element.isElement(n) && n.type !== type && types.includes(n.type) }\n                );\n                return;\n            }\n\n            // wrap\n            ListEditor.buildListItem(editor);\n            Transforms.wrapNodes(editor, { type, children: [], start: startIndex } as CustomElement, {\n                at: editor.selection,\n                match: (n: CustomElement) => Element.isElement(n) && n.type === ElementKinds.listItem\n            });\n        });\n    },\n    unwrapList(editor: TheEditor) {\n        Editor.withoutNormalizing(editor, () => {\n            TheTransforms.unwrapNodesByType(editor, [ElementKinds.bulletedList, ElementKinds.numberedList], { split: true, mode: 'all' });\n            TheTransforms.unwrapNodesByType(editor, [ElementKinds.listItem], { split: true, mode: 'all' });\n        });\n    },\n    wrapList(editor: TheEditor, type: ElementKinds.bulletedList | ElementKinds.numberedList) {\n        Editor.withoutNormalizing(editor, () => {\n            const listItem: CustomElement = {\n                type: ElementKinds.listItem,\n                children: []\n            };\n            const list = {\n                type,\n                children: []\n            };\n            Transforms.wrapNodes(editor, list, { split: true });\n            Transforms.wrapNodes(editor, listItem, { split: true });\n        });\n    },\n    isActive(editor: TheEditor, type: ElementKinds.bulletedList | ElementKinds.numberedList) {\n        const [match] = TheQueries.getNodesByType(editor, type);\n        return !!match;\n    },\n    getActiveList(editor: TheEditor) {\n        const [match] = TheQueries.getNodesByType(editor, LIST_BLOCK_TYPES as string[]);\n        return match;\n    },\n    buildListItem(editor: TheEditor) {\n        const nodes = Editor.nodes(editor, {\n            match: (n: CustomElement) => Editor.isBlock(editor, n),\n            mode: 'lowest'\n        });\n        for (const [node, path] of nodes) {\n            if (!Editor.isVoid(editor, node) && Element.isElement(node) && (node as any).type !== ElementKinds.paragraph) {\n                Transforms.setNodes(\n                    editor,\n                    { type: ElementKinds.paragraph, checked: undefined } as any, // todo remove checked\n                    { at: path }\n                );\n            } else if (Element.isElement(node) && (node as CustomElement).type === ElementKinds.paragraph) {\n                let { textIndent } = node as CustomElement;\n                if (textIndent) {\n                    Transforms.setNodes(\n                        editor,\n                        { textIndent: undefined, indent: undefined } as CustomElement, // remove indent\n                        { at: path }\n                    );\n                }\n            }\n            if ((Node.parent(editor, path) as CustomElement).type !== ElementKinds.listItem) {\n                Transforms.wrapNodes(\n                    editor,\n                    { type: ElementKinds.listItem, children: [] } as CustomElement,\n                    {\n                        at: path,\n                        split: true\n                    }\n                );\n            }\n        }\n    },\n    buildInsertDataChildren(node: CustomElement) {\n        const { children } = node;\n        const listItem = children[0];\n        if (isNodeTypeList(node) && Element.isElement(listItem) && (listItem.children[0] as CustomElement).type === ElementKinds.paragraph) {\n            return node;\n        }\n\n        return ListEditor.buildInsertDataChildren(listItem as CustomElement);\n    }\n};\n"]}

package/esm2022/plugins/list/list.plugin.mjs

@@ -0,0 +1,312 @@
+import { Transforms, Node, Editor, Path } from 'slate';
+import { AngularEditor, getPlainText } from 'slate-angular';
+import { CLIPBOARD_FORMAT_KEY, ElementKinds, PluginMenuIcons, ThePluginMenuItemType } 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)
+        }
+    ],
+    menuItems: [
+        {
+            key: ElementKinds.numberedList,
+            keywords: 'yxlb,youxuliebiao,numbered list,numberedlist,有序列表',
+            execute: editor => ListEditor.toggleList(editor, ElementKinds.numberedList),
+            active: editor => ListEditor.isActive(editor, ElementKinds.numberedList),
+            type: ThePluginMenuItemType.icon,
+            name: '有序列表',
+            description: '插入有序列表',
+            displayKey: '/yxlb',
+            icon: 'list-ordered',
+            menuIcon: PluginMenuIcons.numberedList
+        },
+        {
+            key: ElementKinds.bulletedList,
+            keywords: 'wxlb,wuxuliebiao,bulletedlist,bulleted list,无序列表',
+            execute: editor => ListEditor.toggleList(editor, ElementKinds.bulletedList),
+            active: editor => ListEditor.isActive(editor, ElementKinds.bulletedList),
+            type: ThePluginMenuItemType.icon,
+            name: '无序列表',
+            description: '插入无序列表',
+            displayKey: '/wxlb',
+            icon: 'list-bullet',
+            menuIcon: PluginMenuIcons.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, PluginMenuIcons, ThePluginMenuItemType } 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, TheEditor } from '../../interfaces';\nimport { ListEditor } from './list.editor';\nimport { CustomElement } from '../../custom-types';\n\nexport const withList = <T extends TheEditor>(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: TheEditor) => 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 CustomElement;\n            if (getListTypes().includes(fragmentElement.type)) {\n                const startNodes = getStartListItem([fragmentElement.children[0]] as CustomElement[]);\n                const children = startNodes.concat((fragmentElement.children as CustomElement[]).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: CustomElement) => 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 CustomElement) &&\n                aboveEntry &&\n                !isSingleListItem(fragment[0]) &&\n                hasStableListItem(res.listItem[0])\n            ) {\n                insertListData(editor, { fromList: fragment[0] as CustomElement, 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: CustomElement) => {\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    menuItems: [\n        {\n            key: ElementKinds.numberedList,\n            keywords: 'yxlb,youxuliebiao,numbered list,numberedlist,有序列表',\n            execute: editor => ListEditor.toggleList(editor, ElementKinds.numberedList),\n            active: editor => ListEditor.isActive(editor, ElementKinds.numberedList),\n            type: ThePluginMenuItemType.icon,\n            name: '有序列表',\n            description: '插入有序列表',\n            displayKey: '/yxlb',\n            icon: 'list-ordered',\n            menuIcon: PluginMenuIcons.numberedList\n        },\n        {\n            key: ElementKinds.bulletedList,\n            keywords: 'wxlb,wuxuliebiao,bulletedlist,bulleted list,无序列表',\n            execute: editor => ListEditor.toggleList(editor, ElementKinds.bulletedList),\n            active: editor => ListEditor.isActive(editor, ElementKinds.bulletedList),\n            type: ThePluginMenuItemType.icon,\n            name: '无序列表',\n            description: '插入无序列表',\n            displayKey: '/wxlb',\n            icon: 'list-bullet',\n            menuIcon: PluginMenuIcons.bulletedList\n        }\n    ],\n    options: listOptions\n});\n"]}

package/esm2022/plugins/list/normalizers/get-list-normalizer.mjs

@@ -0,0 +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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

package/esm2022/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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