@worktile/theia 3.0.6 → 3.0.9

package/esm2015/plugins/list/queries/is-selection-at-list-item-start.js

@@ -1,13 +1,13 @@
-import * as TheQueries from '../../../queries';
-import { ElementKinds } from '../../../constants';
-/**
- * Is the selection focus at the start of its parent block.
- */
-export const isSelectionAtListItemStart = (editor) => {
-    const listItemEntry = TheQueries.getAboveByType(editor, [ElementKinds.listItem]);
-    if (listItemEntry) {
-        return TheQueries.isStart(editor, editor.selection.focus, listItemEntry[1]);
-    }
-    return false;
-};
+import * as TheQueries from '../../../queries';
+import { ElementKinds } from '../../../constants';
+/**
+ * Is the selection focus at the start of its parent block.
+ */
+export const isSelectionAtListItemStart = (editor) => {
+    const listItemEntry = TheQueries.getAboveByType(editor, [ElementKinds.listItem]);
+    if (listItemEntry) {
+        return TheQueries.isStart(editor, editor.selection.focus, listItemEntry[1]);
+    }
+    return false;
+};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtc2VsZWN0aW9uLWF0LWxpc3QtaXRlbS1zdGFydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3NyYy9wbHVnaW5zL2xpc3QvcXVlcmllcy9pcy1zZWxlY3Rpb24tYXQtbGlzdC1pdGVtLXN0YXJ0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxVQUFVLE1BQU0sa0JBQWtCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRWxEOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sMEJBQTBCLEdBQUcsQ0FBQyxNQUFjLEVBQUUsRUFBRTtJQUN6RCxNQUFNLGFBQWEsR0FBRyxVQUFVLENBQUMsY0FBYyxDQUFDLE1BQU0sRUFBRSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO0lBQ2pGLElBQUksYUFBYSxFQUFFO1FBQ2YsT0FBTyxVQUFVLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsU0FBUyxDQUFDLEtBQUssRUFBRSxhQUFhLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztLQUMvRTtJQUNELE9BQU8sS0FBSyxDQUFDO0FBQ2pCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVkaXRvciB9IGZyb20gJ3NsYXRlJztcbmltcG9ydCAqIGFzIFRoZVF1ZXJpZXMgZnJvbSAnLi4vLi4vLi4vcXVlcmllcyc7XG5pbXBvcnQgeyBFbGVtZW50S2luZHMgfSBmcm9tICcuLi8uLi8uLi9jb25zdGFudHMnO1xuXG4vKipcbiAqIElzIHRoZSBzZWxlY3Rpb24gZm9jdXMgYXQgdGhlIHN0YXJ0IG9mIGl0cyBwYXJlbnQgYmxvY2suXG4gKi9cbmV4cG9ydCBjb25zdCBpc1NlbGVjdGlvbkF0TGlzdEl0ZW1TdGFydCA9IChlZGl0b3I6IEVkaXRvcikgPT4ge1xuICAgIGNvbnN0IGxpc3RJdGVtRW50cnkgPSBUaGVRdWVyaWVzLmdldEFib3ZlQnlUeXBlKGVkaXRvciwgW0VsZW1lbnRLaW5kcy5saXN0SXRlbV0pO1xuICAgIGlmIChsaXN0SXRlbUVudHJ5KSB7XG4gICAgICAgIHJldHVybiBUaGVRdWVyaWVzLmlzU3RhcnQoZWRpdG9yLCBlZGl0b3Iuc2VsZWN0aW9uLmZvY3VzLCBsaXN0SXRlbUVudHJ5WzFdKTtcbiAgICB9XG4gICAgcmV0dXJuIGZhbHNlO1xufTtcbiJdfQ==

package/esm2015/plugins/list/queries/is-selection-in-same-list-item.js

@@ -1,17 +1,17 @@
-import { Range, Path } from 'slate';
-import { getAboveByType } from '../../../queries/get-above-by-type';
-import { ElementKinds } from '../../../constants/node-types';
-/**
- * Is the selection in same li
- */
-export const isSelectionInSameListItem = (editor) => {
-    const { selection } = editor;
-    if (!selection) {
-        return false;
-    }
-    const [start, end] = Range.edges(selection);
-    const startListItemEntry = getAboveByType(editor, ElementKinds.listItem, { at: start.path });
-    const endListItemEntry = getAboveByType(editor, ElementKinds.listItem, { at: end.path });
-    return startListItemEntry && endListItemEntry && Path.equals(startListItemEntry[1], endListItemEntry[1]);
-};
+import { Range, Path } from 'slate';
+import { getAboveByType } from '../../../queries/get-above-by-type';
+import { ElementKinds } from '../../../constants/node-types';
+/**
+ * Is the selection in same li
+ */
+export const isSelectionInSameListItem = (editor) => {
+    const { selection } = editor;
+    if (!selection) {
+        return false;
+    }
+    const [start, end] = Range.edges(selection);
+    const startListItemEntry = getAboveByType(editor, ElementKinds.listItem, { at: start.path });
+    const endListItemEntry = getAboveByType(editor, ElementKinds.listItem, { at: end.path });
+    return startListItemEntry && endListItemEntry && Path.equals(startListItemEntry[1], endListItemEntry[1]);
+};
 //# sourceMappingURL=data:application/json;base64,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

package/esm2015/plugins/list/queries/is-single-list-item.js

@@ -1,9 +1,9 @@
-import { hasListInListItem } from './has-list-in-list-item';
-import { isNodeTypeList } from './is-node-type-list';
-/**
- * list 中 是否是单个listItem，且listItem没有子列表
- */
-export const isSingleListItem = (list) => {
-    return isNodeTypeList(list) && list.children.length === 1 && !hasListInListItem(list.children[0]);
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtc2luZ2xlLWxpc3QtaXRlbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3NyYy9wbHVnaW5zL2xpc3QvcXVlcmllcy9pcy1zaW5nbGUtbGlzdC1pdGVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzVELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVyRDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsSUFBVSxFQUFFLEVBQUU7SUFDM0MsT0FBTyxjQUFjLENBQUMsSUFBSSxDQUFDLElBQUssSUFBSSxDQUFDLFFBQW1CLENBQUMsTUFBTSxLQUFLLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFZLENBQUMsQ0FBQztBQUM3SCxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOb2RlLCBFbGVtZW50IH0gZnJvbSAnc2xhdGUnO1xuaW1wb3J0IHsgaGFzTGlzdEluTGlzdEl0ZW0gfSBmcm9tICcuL2hhcy1saXN0LWluLWxpc3QtaXRlbSc7XG5pbXBvcnQgeyBpc05vZGVUeXBlTGlzdCB9IGZyb20gJy4vaXMtbm9kZS10eXBlLWxpc3QnO1xuXG4vKipcbiAqIGxpc3Qg5LitIOaYr+WQpuaYr+WNleS4qmxpc3RJdGVt77yM5LiUbGlzdEl0ZW3msqHmnInlrZDliJfooahcbiAqL1xuZXhwb3J0IGNvbnN0IGlzU2luZ2xlTGlzdEl0ZW0gPSAobGlzdDogTm9kZSkgPT4ge1xuICAgIHJldHVybiBpc05vZGVUeXBlTGlzdChsaXN0KSAmJiAobGlzdC5jaGlsZHJlbiBhcyBOb2RlW10pLmxlbmd0aCA9PT0gMSAmJiAhaGFzTGlzdEluTGlzdEl0ZW0obGlzdC5jaGlsZHJlblswXSBhcyBFbGVtZW50KTtcbn07XG4iXX0=
+import { hasListInListItem } from './has-list-in-list-item';
+import { isNodeTypeList } from './is-node-type-list';
+/**
+ * list 中 是否是单个listItem，且listItem没有子列表
+ */
+export const isSingleListItem = (list) => {
+    return isNodeTypeList(list) && list.children.length === 1 && !hasListInListItem(list.children[0]);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtc2luZ2xlLWxpc3QtaXRlbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3NyYy9wbHVnaW5zL2xpc3QvcXVlcmllcy9pcy1zaW5nbGUtbGlzdC1pdGVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzVELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVyRDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsSUFBVSxFQUFFLEVBQUU7SUFDM0MsT0FBTyxjQUFjLENBQUMsSUFBSSxDQUFDLElBQUssSUFBSSxDQUFDLFFBQW1CLENBQUMsTUFBTSxLQUFLLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFZLENBQUMsQ0FBQztBQUM3SCxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOb2RlLCBFbGVtZW50IH0gZnJvbSAnc2xhdGUnO1xyXG5pbXBvcnQgeyBoYXNMaXN0SW5MaXN0SXRlbSB9IGZyb20gJy4vaGFzLWxpc3QtaW4tbGlzdC1pdGVtJztcclxuaW1wb3J0IHsgaXNOb2RlVHlwZUxpc3QgfSBmcm9tICcuL2lzLW5vZGUtdHlwZS1saXN0JztcclxuXHJcbi8qKlxyXG4gKiBsaXN0IOS4rSDmmK/lkKbmmK/ljZXkuKpsaXN0SXRlbe+8jOS4lGxpc3RJdGVt5rKh5pyJ5a2Q5YiX6KGoXHJcbiAqL1xyXG5leHBvcnQgY29uc3QgaXNTaW5nbGVMaXN0SXRlbSA9IChsaXN0OiBOb2RlKSA9PiB7XHJcbiAgICByZXR1cm4gaXNOb2RlVHlwZUxpc3QobGlzdCkgJiYgKGxpc3QuY2hpbGRyZW4gYXMgTm9kZVtdKS5sZW5ndGggPT09IDEgJiYgIWhhc0xpc3RJbkxpc3RJdGVtKGxpc3QuY2hpbGRyZW5bMF0gYXMgRWxlbWVudCk7XHJcbn07XHJcbiJdfQ==

package/esm2015/plugins/list/transforms/insert-list-data.js

@@ -1,72 +1,72 @@
-import { Node, Path, Transforms, Editor } from 'slate';
-import * as TheQueries from '../../../queries';
-import { hasListInListItem } from '../queries/has-list-in-list-item';
-import { getListItemEntry } from '../queries/get-list-item-entry';
-export const insertListData = (editor, { fromList, toListItemEntry }) => {
-    const { children } = fromList;
-    const [toListItem, toListItemPath] = toListItemEntry;
-    const nextListItemPath = Path.next(toListItemPath);
-    const toListItemIsEmptyParagraph = TheQueries.isEmptyParagraph(editor, editor.selection.anchor);
-    const hasSubList = hasListInListItem(toListItem);
-    let selectPath = [...toListItemPath];
-    const liIndex = selectPath.pop();
-    selectPath = [...selectPath, liIndex + children.length];
-    Editor.withoutNormalizing(editor, () => {
-        if (toListItemIsEmptyParagraph && hasSubList) {
-            Transforms.insertNodes(editor, children, { at: nextListItemPath });
-        }
-        else {
-            const insertListItemPath = toListItemIsEmptyParagraph ? toListItemPath : nextListItemPath;
-            // 如果粘贴目标listItem为空，则先删除listItem
-            if (toListItemIsEmptyParagraph) {
-                Transforms.removeNodes(editor, { at: insertListItemPath });
-                selectPath = Path.previous(selectPath);
-            }
-            Transforms.insertNodes(editor, children, { at: insertListItemPath });
-        }
-        /**
-         * 粘贴目标lisItem有子列表
-         */
-        if (hasSubList) {
-            const paragraphPath = toListItemPath.concat([0]);
-            const nextSubListPath = Path.next(paragraphPath);
-            // 判断粘贴数据是否是多级
-            if (hasListInListItem(fromList.children[0])) {
-                // 设置粘贴后正确选区
-                Transforms.select(editor, Editor.end(editor, nextListItemPath));
-                // 获取当前选区所在listItem entry
-                const currentListItemEntry = getListItemEntry(editor, {});
-                // 获取粘贴目标listItem中的子列表
-                const { children: subListChildren } = Node.get(editor, nextSubListPath);
-                /**
-                 * 复制子列表数据
-                 * 之所以是复制，而不是移动，因为无法单纯一次性移动子列表的所有listItem（不包含subList本身）到目标位置，
-                 * 需要循环移动才可以
-                 **/
-                Transforms.insertNodes(editor, subListChildren, {
-                    at: Path.next(currentListItemEntry.listItem[1])
-                });
-                // 删除已被复制后无用的listItem/listItem subList
-                Transforms.delete(editor, {
-                    at: toListItemIsEmptyParagraph ? toListItemPath : nextSubListPath
-                });
-                return;
-            }
-            Transforms.select(editor, Editor.end(editor, selectPath));
-            // 粘贴数据不是多级
-            const currentListItemEntry = getListItemEntry(editor, {});
-            Transforms.moveNodes(editor, {
-                at: nextSubListPath,
-                to: currentListItemEntry.listItem[1].concat(1)
-            });
-            if (toListItemIsEmptyParagraph) {
-                Transforms.delete(editor, { at: toListItemPath });
-            }
-            return;
-        }
-    });
-    // 粘贴目标listItem没有子列表, 设置选区
-    Transforms.select(editor, Editor.end(editor, selectPath));
-    return;
-};
+import { Node, Path, Transforms, Editor } from 'slate';
+import * as TheQueries from '../../../queries';
+import { hasListInListItem } from '../queries/has-list-in-list-item';
+import { getListItemEntry } from '../queries/get-list-item-entry';
+export const insertListData = (editor, { fromList, toListItemEntry }) => {
+    const { children } = fromList;
+    const [toListItem, toListItemPath] = toListItemEntry;
+    const nextListItemPath = Path.next(toListItemPath);
+    const toListItemIsEmptyParagraph = TheQueries.isEmptyParagraph(editor, editor.selection.anchor);
+    const hasSubList = hasListInListItem(toListItem);
+    let selectPath = [...toListItemPath];
+    const liIndex = selectPath.pop();
+    selectPath = [...selectPath, liIndex + children.length];
+    Editor.withoutNormalizing(editor, () => {
+        if (toListItemIsEmptyParagraph && hasSubList) {
+            Transforms.insertNodes(editor, children, { at: nextListItemPath });
+        }
+        else {
+            const insertListItemPath = toListItemIsEmptyParagraph ? toListItemPath : nextListItemPath;
+            // 如果粘贴目标listItem为空，则先删除listItem
+            if (toListItemIsEmptyParagraph) {
+                Transforms.removeNodes(editor, { at: insertListItemPath });
+                selectPath = Path.previous(selectPath);
+            }
+            Transforms.insertNodes(editor, children, { at: insertListItemPath });
+        }
+        /**
+         * 粘贴目标lisItem有子列表
+         */
+        if (hasSubList) {
+            const paragraphPath = toListItemPath.concat([0]);
+            const nextSubListPath = Path.next(paragraphPath);
+            // 判断粘贴数据是否是多级
+            if (hasListInListItem(fromList.children[0])) {
+                // 设置粘贴后正确选区
+                Transforms.select(editor, Editor.end(editor, nextListItemPath));
+                // 获取当前选区所在listItem entry
+                const currentListItemEntry = getListItemEntry(editor, {});
+                // 获取粘贴目标listItem中的子列表
+                const { children: subListChildren } = Node.get(editor, nextSubListPath);
+                /**
+                 * 复制子列表数据
+                 * 之所以是复制，而不是移动，因为无法单纯一次性移动子列表的所有listItem（不包含subList本身）到目标位置，
+                 * 需要循环移动才可以
+                 **/
+                Transforms.insertNodes(editor, subListChildren, {
+                    at: Path.next(currentListItemEntry.listItem[1])
+                });
+                // 删除已被复制后无用的listItem/listItem subList
+                Transforms.delete(editor, {
+                    at: toListItemIsEmptyParagraph ? toListItemPath : nextSubListPath
+                });
+                return;
+            }
+            Transforms.select(editor, Editor.end(editor, selectPath));
+            // 粘贴数据不是多级
+            const currentListItemEntry = getListItemEntry(editor, {});
+            Transforms.moveNodes(editor, {
+                at: nextSubListPath,
+                to: currentListItemEntry.listItem[1].concat(1)
+            });
+            if (toListItemIsEmptyParagraph) {
+                Transforms.delete(editor, { at: toListItemPath });
+            }
+            return;
+        }
+    });
+    // 粘贴目标listItem没有子列表, 设置选区
+    Transforms.select(editor, Editor.end(editor, selectPath));
+    return;
+};
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"insert-list-data.js","sourceRoot":"","sources":["../../../../../../packages/src/plugins/list/transforms/insert-list-data.ts"],"names":[],"mappings":"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","sourcesContent":["import { NodeEntry, Ancestor, Node, Path, Transforms, Editor, Element } from 'slate';\nimport * as TheQueries from '../../../queries';\nimport { hasListInListItem } from '../queries/has-list-in-list-item';\nimport { getListItemEntry } from '../queries/get-list-item-entry';\n\nexport interface InsertListDataOptions {\n    /**\n     * 要粘贴的list数据\n     */\n    fromList: Element;\n\n    /**\n     * 粘贴list数据至此\n     */\n    toListItemEntry: NodeEntry<Ancestor>;\n}\n\nexport const insertListData = (editor: Editor, { fromList, toListItemEntry }: InsertListDataOptions) => {\n    const { children } = fromList;\n    const [toListItem, toListItemPath] = toListItemEntry;\n    const nextListItemPath = Path.next(toListItemPath);\n    const toListItemIsEmptyParagraph = TheQueries.isEmptyParagraph(editor, editor.selection.anchor);\n    const hasSubList = hasListInListItem(toListItem as Element);\n\n    let selectPath = [...toListItemPath];\n    const liIndex = selectPath.pop();\n    selectPath = [...selectPath, liIndex + children.length];\n\n    Editor.withoutNormalizing(editor, () => {\n        if (toListItemIsEmptyParagraph && hasSubList) {\n            Transforms.insertNodes(editor, children, { at: nextListItemPath });\n        } else {\n            const insertListItemPath = toListItemIsEmptyParagraph ? toListItemPath : nextListItemPath;\n            // 如果粘贴目标listItem为空，则先删除listItem\n            if (toListItemIsEmptyParagraph) {\n                Transforms.removeNodes(editor, { at: insertListItemPath });\n                selectPath = Path.previous(selectPath);\n            }\n            Transforms.insertNodes(editor, children, { at: insertListItemPath });\n        }\n\n        /**\n         * 粘贴目标lisItem有子列表\n         */\n        if (hasSubList) {\n            const paragraphPath = toListItemPath.concat([0]);\n            const nextSubListPath = Path.next(paragraphPath);\n\n            // 判断粘贴数据是否是多级\n            if (hasListInListItem(fromList.children[0] as Element)) {\n                // 设置粘贴后正确选区\n                Transforms.select(editor, Editor.end(editor, nextListItemPath));\n\n                // 获取当前选区所在listItem entry\n                const currentListItemEntry = getListItemEntry(editor, {});\n                // 获取粘贴目标listItem中的子列表\n                const { children: subListChildren } = Node.get(editor, nextSubListPath) as Element;\n\n                /**\n                 * 复制子列表数据\n                 * 之所以是复制，而不是移动，因为无法单纯一次性移动子列表的所有listItem（不包含subList本身）到目标位置，\n                 * 需要循环移动才可以\n                 **/\n                Transforms.insertNodes(editor, subListChildren as Node[], {\n                    at: Path.next(currentListItemEntry.listItem[1])\n                });\n                // 删除已被复制后无用的listItem/listItem subList\n                Transforms.delete(editor, {\n                    at: toListItemIsEmptyParagraph ? toListItemPath : nextSubListPath\n                });\n                return;\n            }\n\n            Transforms.select(editor, Editor.end(editor, selectPath));\n\n            // 粘贴数据不是多级\n            const currentListItemEntry = getListItemEntry(editor, {});\n            Transforms.moveNodes(editor, {\n                at: nextSubListPath,\n                to: currentListItemEntry.listItem[1].concat(1)\n            });\n\n            if (toListItemIsEmptyParagraph) {\n                Transforms.delete(editor, { at: toListItemPath });\n            }\n            return;\n        }\n    });\n\n    // 粘贴目标listItem没有子列表, 设置选区\n    Transforms.select(editor, Editor.end(editor, selectPath));\n    return;\n};\n"]}

package/esm2015/plugins/list/transforms/insert-list-item.js

@@ -1,73 +1,73 @@
-import { Editor, Path, Range, Transforms, Element } from 'slate';
-import { TheEditor } from '../../../interfaces';
-import { ElementKinds } from '../../../constants';
-import * as TheQueries from '../../../queries';
-/**
- * Insert list item if selection in li>p.
- */
-export const insertListItem = (editor) => {
-    if (editor.selection && !TheQueries.isRangeAtRoot(editor.selection)) {
-        const paragraphEntry = TheQueries.getAboveByType(editor, ElementKinds.paragraph);
-        if (!paragraphEntry) {
-            return;
-        }
-        const [, paragraphPath] = paragraphEntry;
-        const [listItemNode, listItemPath] = Editor.parent(editor, paragraphPath);
-        if (Element.isElement(listItemNode) && listItemNode.type !== ElementKinds.listItem) {
-            return;
-        }
-        if (!Range.isCollapsed(editor.selection)) {
-            Transforms.delete(editor);
-        }
-        const isEnd = TheQueries.isBlockTextEmptyAfterSelection(editor);
-        const nextNodePath = Path.next(paragraphPath);
-        const nextListItemPath = Path.next(listItemPath);
-        const nextEnd = Editor.end(editor, listItemPath);
-        /**
-         * If not end, split nodes, wrap a list item on the new paragraph and move it to the next list item
-         */
-        if (!isEnd) {
-            Editor.withoutNormalizing(editor, () => {
-                Transforms.splitNodes(editor, { at: editor.selection, always: true });
-                Transforms.wrapNodes(editor, {
-                    type: ElementKinds.listItem,
-                    children: []
-                }, { at: nextNodePath });
-                Transforms.moveNodes(editor, {
-                    at: nextNodePath,
-                    to: nextListItemPath
-                });
-            });
-        }
-        else {
-            /**
-             * If end, split nodes
-             */
-            Editor.withoutNormalizing(editor, () => {
-                Transforms.splitNodes(editor, {
-                    always: true,
-                    mode: 'highest',
-                    match: node => {
-                        const path = node && TheEditor.findPath(editor, node);
-                        return path && path.length === nextListItemPath.length;
-                    }
-                });
-            });
-        }
-        /**
-         * If there is a list in the list item, move it to the next list item
-         */
-        if (TheQueries.getNode(editor, nextNodePath)) {
-            Transforms.moveNodes(editor, {
-                at: Editor.range(editor, nextNodePath, nextEnd),
-                to: nextListItemPath.concat(1),
-                match: node => {
-                    // TODO: types
-                    return listItemNode.children.includes(node);
-                }
-            });
-        }
-        return true;
-    }
-};
+import { Editor, Path, Range, Transforms, Element } from 'slate';
+import { TheEditor } from '../../../interfaces';
+import { ElementKinds } from '../../../constants';
+import * as TheQueries from '../../../queries';
+/**
+ * Insert list item if selection in li>p.
+ */
+export const insertListItem = (editor) => {
+    if (editor.selection && !TheQueries.isRangeAtRoot(editor.selection)) {
+        const paragraphEntry = TheQueries.getAboveByType(editor, ElementKinds.paragraph);
+        if (!paragraphEntry) {
+            return;
+        }
+        const [, paragraphPath] = paragraphEntry;
+        const [listItemNode, listItemPath] = Editor.parent(editor, paragraphPath);
+        if (Element.isElement(listItemNode) && listItemNode.type !== ElementKinds.listItem) {
+            return;
+        }
+        if (!Range.isCollapsed(editor.selection)) {
+            Transforms.delete(editor);
+        }
+        const isEnd = TheQueries.isBlockTextEmptyAfterSelection(editor);
+        const nextNodePath = Path.next(paragraphPath);
+        const nextListItemPath = Path.next(listItemPath);
+        const nextEnd = Editor.end(editor, listItemPath);
+        /**
+         * If not end, split nodes, wrap a list item on the new paragraph and move it to the next list item
+         */
+        if (!isEnd) {
+            Editor.withoutNormalizing(editor, () => {
+                Transforms.splitNodes(editor, { at: editor.selection, always: true });
+                Transforms.wrapNodes(editor, {
+                    type: ElementKinds.listItem,
+                    children: []
+                }, { at: nextNodePath });
+                Transforms.moveNodes(editor, {
+                    at: nextNodePath,
+                    to: nextListItemPath
+                });
+            });
+        }
+        else {
+            /**
+             * If end, split nodes
+             */
+            Editor.withoutNormalizing(editor, () => {
+                Transforms.splitNodes(editor, {
+                    always: true,
+                    mode: 'highest',
+                    match: node => {
+                        const path = node && TheEditor.findPath(editor, node);
+                        return path && path.length === nextListItemPath.length;
+                    }
+                });
+            });
+        }
+        /**
+         * If there is a list in the list item, move it to the next list item
+         */
+        if (TheQueries.getNode(editor, nextNodePath)) {
+            Transforms.moveNodes(editor, {
+                at: Editor.range(editor, nextNodePath, nextEnd),
+                to: nextListItemPath.concat(1),
+                match: node => {
+                    // TODO: types
+                    return listItemNode.children.includes(node);
+                }
+            });
+        }
+        return true;
+    }
+};
 //# sourceMappingURL=data:application/json;base64,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

package/esm2015/plugins/list/transforms/move-list-item-down.js

@@ -1,41 +1,41 @@
-import { Editor, Path, Transforms } from 'slate';
-import { getListItemEntry } from '../queries/get-list-item-entry';
-import { hasListInListItem } from '../queries/has-list-in-list-item';
-import { moveListItemSublistItemsToList } from './move-list-item-sublist-items-to-list';
-import { isNodeTypeList } from '../queries/is-node-type-list';
-export const moveListItemDown = (editor, { list, listItem }) => {
-    const [listNode] = list;
-    const [, listItemPath] = listItem;
-    Editor.withoutNormalizing(editor, () => {
-        // 以前的兄弟是新父级
-        const previousSiblingItem = Editor.node(editor, Path.previous(listItemPath));
-        if (previousSiblingItem) {
-            const [previousNode, previousPath] = previousSiblingItem;
-            const lastChildIndexOfPreviousNode = previousNode.children.length - 1;
-            const lastChildOfPreviousNode = previousNode.children[lastChildIndexOfPreviousNode];
-            const newPath = previousPath.concat(isNodeTypeList(lastChildOfPreviousNode)
-                ? [lastChildIndexOfPreviousNode, lastChildOfPreviousNode.children.length]
-                : [previousNode.children.length]);
-            if (!isNodeTypeList(lastChildOfPreviousNode)) {
-                // 创建新子列表
-                const type = listNode.type;
-                Transforms.wrapNodes(editor, { type, children: [] }, {
-                    at: listItemPath
-                });
-            }
-            // 将当前listItem移动到子列表
-            Transforms.moveNodes(editor, {
-                at: listItemPath,
-                to: newPath
-            });
-            const currentListItemEntry = getListItemEntry(editor, {});
-            if (hasListInListItem(currentListItemEntry.listItem[0])) {
-                moveListItemSublistItemsToList(editor, {
-                    fromListItem: currentListItemEntry.listItem,
-                    toList: currentListItemEntry.list
-                });
-            }
-        }
-    });
-};
-//# sourceMappingURL=data:application/json;base64,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
+import { Editor, Path, Transforms } from 'slate';
+import { getListItemEntry } from '../queries/get-list-item-entry';
+import { hasListInListItem } from '../queries/has-list-in-list-item';
+import { moveListItemSublistItemsToList } from './move-list-item-sublist-items-to-list';
+import { isNodeTypeList } from '../queries/is-node-type-list';
+export const moveListItemDown = (editor, { list, listItem }) => {
+    const [listNode] = list;
+    const [, listItemPath] = listItem;
+    Editor.withoutNormalizing(editor, () => {
+        // 以前的兄弟是新父级
+        const previousSiblingItem = Editor.node(editor, Path.previous(listItemPath));
+        if (previousSiblingItem) {
+            const [previousNode, previousPath] = previousSiblingItem;
+            const lastChildIndexOfPreviousNode = previousNode.children.length - 1;
+            const lastChildOfPreviousNode = previousNode.children[lastChildIndexOfPreviousNode];
+            const newPath = previousPath.concat(isNodeTypeList(lastChildOfPreviousNode)
+                ? [lastChildIndexOfPreviousNode, lastChildOfPreviousNode.children.length]
+                : [previousNode.children.length]);
+            if (!isNodeTypeList(lastChildOfPreviousNode)) {
+                // 创建新子列表
+                const type = listNode.type;
+                Transforms.wrapNodes(editor, { type, children: [] }, {
+                    at: listItemPath
+                });
+            }
+            // 将当前listItem移动到子列表
+            Transforms.moveNodes(editor, {
+                at: listItemPath,
+                to: newPath
+            });
+            const currentListItemEntry = getListItemEntry(editor, {});
+            if (hasListInListItem(currentListItemEntry.listItem[0])) {
+                moveListItemSublistItemsToList(editor, {
+                    fromListItem: currentListItemEntry.listItem,
+                    toList: currentListItemEntry.list
+                });
+            }
+        }
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/plugins/list/transforms/move-list-item-sublist-items-to-list-item-sublist.js

@@ -1,43 +1,43 @@
-import { Path, Transforms } from 'slate';
-import { moveChildren } from '../../../transforms/move-children';
-import { getListItemSublist } from '../queries/get-list-item-sublist';
-import * as TheQueries from '../../../queries';
-/**
- * Move fromListItem sublist list items to the end of `toListItem` sublist.
- * If there is no `toListItem` sublist, insert one.
- */
-export const moveListItemSublistItemsToListItemSublist = (editor, { fromListItem, toListItem, start }, options) => {
-    const [, fromListItemPath] = fromListItem;
-    const [toListItemNode, toListItemPath] = toListItem;
-    const fromListItemSublist = getListItemSublist(fromListItem, options);
-    if (!fromListItemSublist)
-        return 0;
-    const [, fromListItemSublistPath] = fromListItemSublist;
-    const toListItemSublist = getListItemSublist(toListItem, options);
-    let to;
-    if (!toListItemSublist) {
-        const fromList = TheQueries.getParent(editor, fromListItemPath);
-        if (!fromList)
-            return 0;
-        const [fromListNode] = fromList;
-        const fromListType = fromListNode.type;
-        const toListItemSublistPath = toListItemPath.concat([toListItemNode.children.length]);
-        Transforms.insertNodes(editor, { type: fromListType, children: [] }, { at: toListItemSublistPath });
-        to = toListItemSublistPath.concat([0]);
-    }
-    else if (start) {
-        const [, toListItemSublistPath] = toListItemSublist;
-        to = toListItemSublistPath.concat([0]);
-    }
-    else {
-        to = Path.next(TheQueries.getLastChildPath(toListItemSublist));
-    }
-    const moved = moveChildren(editor, {
-        at: Path.previous(fromListItemSublistPath),
-        to
-    });
-    // Remove the empty list
-    Transforms.delete(editor, { at: fromListItemPath });
-    return moved;
-};
+import { Path, Transforms } from 'slate';
+import { moveChildren } from '../../../transforms/move-children';
+import { getListItemSublist } from '../queries/get-list-item-sublist';
+import * as TheQueries from '../../../queries';
+/**
+ * Move fromListItem sublist list items to the end of `toListItem` sublist.
+ * If there is no `toListItem` sublist, insert one.
+ */
+export const moveListItemSublistItemsToListItemSublist = (editor, { fromListItem, toListItem, start }, options) => {
+    const [, fromListItemPath] = fromListItem;
+    const [toListItemNode, toListItemPath] = toListItem;
+    const fromListItemSublist = getListItemSublist(fromListItem, options);
+    if (!fromListItemSublist)
+        return 0;
+    const [, fromListItemSublistPath] = fromListItemSublist;
+    const toListItemSublist = getListItemSublist(toListItem, options);
+    let to;
+    if (!toListItemSublist) {
+        const fromList = TheQueries.getParent(editor, fromListItemPath);
+        if (!fromList)
+            return 0;
+        const [fromListNode] = fromList;
+        const fromListType = fromListNode.type;
+        const toListItemSublistPath = toListItemPath.concat([toListItemNode.children.length]);
+        Transforms.insertNodes(editor, { type: fromListType, children: [] }, { at: toListItemSublistPath });
+        to = toListItemSublistPath.concat([0]);
+    }
+    else if (start) {
+        const [, toListItemSublistPath] = toListItemSublist;
+        to = toListItemSublistPath.concat([0]);
+    }
+    else {
+        to = Path.next(TheQueries.getLastChildPath(toListItemSublist));
+    }
+    const moved = moveChildren(editor, {
+        at: Path.previous(fromListItemSublistPath),
+        to
+    });
+    // Remove the empty list
+    Transforms.delete(editor, { at: fromListItemPath });
+    return moved;
+};
 //# sourceMappingURL=data:application/json;base64,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