@worktile/theia 3.0.8 → 3.0.9

package/esm2015/plugins/list/list.plugin.js

@@ -1,281 +1,281 @@
-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) => {
-    var _a, _b;
-    const { insertBreak, deleteBackward, onKeydown, insertData, setFragmentData, renderElement } = editor;
-    const validLiChildrenTypes = (_b = (_a = getPluginOptions(editor, PluginKeys.list)) === null || _a === void 0 ? void 0 : _a.validLiChildrenTypes) !== null && _b !== void 0 ? _b : [];
-    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: [
-                    Object.assign(Object.assign({}, 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 = [
-                    Object.assign(Object.assign({}, 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
-});
+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) => {
+    var _a, _b;
+    const { insertBreak, deleteBackward, onKeydown, insertData, setFragmentData, renderElement } = editor;
+    const validLiChildrenTypes = (_b = (_a = getPluginOptions(editor, PluginKeys.list)) === null || _a === void 0 ? void 0 : _a.validLiChildrenTypes) !== null && _b !== void 0 ? _b : [];
+    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: [
+                    Object.assign(Object.assign({}, 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 = [
+                    Object.assign(Object.assign({}, 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"]}