feat(Clipboard): updated trimListItems

Author: makhnatkin

src/extensions/base/BaseSchema/BaseSchemaSpecs/index.ts

@@ -1,4 +1,6 @@
-import type {Node, NodeSpec} from 'prosemirror-model';
+import type {NodeSpec} from 'prosemirror-model';
+
+import {isEmptyString} from 'src/utils';
 
 import type {ExtensionAuto} from '../../../../core';
 import {nodeTypeFactory} from '../../../../utils/schema';
@@ -92,19 +94,3 @@ export const BaseSchemaSpecs: ExtensionAuto<BaseSchemaSpecsOptions> = (builder,
             },
         }));
 };
-
-const isEmptyString = (node: Node) => {
-    if (!node.content.size) {
-        return true;
-    }
-
-    if (
-        node.childCount === 1 &&
-        node.child(0).type.name === 'text' &&
-        node.child(0).text?.trim() === ''
-    ) {
-        return true;
-    }
-
-    return false;
-};

src/extensions/behavior/Clipboard/clipboard.ts

@@ -297,12 +297,6 @@ function getCopyContent(state: EditorState): Slice {
 
     let slice = getSelectionContent(sel);
 
-    // trim empty list items
-    const trimedContent = trimListItems(slice.content);
-    if (trimedContent !== slice.content) {
-        slice = new Slice(trimedContent, 1, 1);
-    }
-
     // replace first node with paragraph if needed
     if (
         slice.content.firstChild?.isTextblock &&
@@ -326,6 +320,12 @@ function getCopyContent(state: EditorState): Slice {
                 slice.openStart,
             );
         }
+    } else {
+        // trim empty list items
+        const trimedContent = trimListItems(slice.content);
+        if (trimedContent !== slice.content) {
+            slice = new Slice(trimedContent, 1, 1);
+        }
     }
 
     return slice;

src/extensions/behavior/Clipboard/utils.test.ts

@@ -63,11 +63,13 @@ describe('trimListItems', () => {
         );
     });
 
-    it('removes an entire list if it contains only empty list items', () => {
+    it('trims a list to one empty list item if it contains only empty list items', () => {
         const fragment = doc(bulletList(listItem(), listItem(), listItem())).content;
 
         const trimmedFragment = trimListItems(fragment);
-        expect(schema.nodes.doc.create(null, trimmedFragment)).toMatchNode(doc());
+        expect(schema.nodes.doc.create(null, trimmedFragment)).toMatchNode(
+            doc(bulletList(listItem())),
+        );
     });
 
     it('correctly handles multiple lists in a single fragment', () => {

src/extensions/behavior/Clipboard/utils.ts

@@ -1,5 +1,8 @@
 import {Fragment, type Node} from 'prosemirror-model';
 
+import {isListItemNode, isListNode} from 'src/extensions/markdown/Lists/utils';
+import {isEmptyString} from 'src/utils';
+
 /** Сontains all data formats known to us */
 export enum DataTransferType {
     Text = 'text/plain',
@@ -59,55 +62,58 @@ export function extractTextContentFromHtml(html: string) {
     return null;
 }
 
+function isListItemEmpty(node: Node): boolean {
+    let isEmpty = true;
+    node.content.forEach((child) => {
+        if (!isEmptyString(child)) {
+            isEmpty = false;
+        }
+    });
+    return isEmpty;
+}
+
 export function trimListItems(fragment: Fragment): Fragment {
     let modified = false;
     const newChildren: Node[] = [];
 
     fragment.forEach((contentNode) => {
-        if (['bullet_list', 'ordered_list'].includes(contentNode.type.name)) {
-            const listItems: Node[] = [];
-            let firstNonEmptyFound = false;
-            let lastNonEmptyIndex = -1;
-
-            contentNode.forEach((node) => {
-                if (node.type.name === 'list_item') {
-                    let hasContent = false;
-
-                    node.content.forEach((child) => {
-                        if (
-                            (child.isText && child.text?.trim().length) ||
-                            (!child.isText && child.content.size > 0)
-                        ) {
-                            hasContent = true;
-                        }
-                    });
-
-                    if (hasContent) {
-                        firstNonEmptyFound = true;
-                        lastNonEmptyIndex = listItems.length;
-                    } else if (!firstNonEmptyFound) {
-                        modified = true;
-                        return;
-                    }
-                }
+        let result = contentNode;
 
-                listItems.push(node);
-            });
-
-            if (lastNonEmptyIndex >= 0 && listItems.length > lastNonEmptyIndex + 1) {
-                modified = true;
+        if (isListNode(contentNode)) {
+            const itemsArray: Node[] = Array.from(contentNode.content.content);
+            if (itemsArray.length === 0) {
+                return;
             }
 
-            if (modified) {
-                listItems.length = lastNonEmptyIndex + 1;
+            const initialStart = 0;
+            const initialEnd = itemsArray.length - 1;
+            let start = initialStart;
+            let end = initialEnd;
+
+            while (start <= end) {
+                if (isListItemNode(itemsArray[start])) {
+                    if (!isListItemEmpty(itemsArray[start])) {
+                        break;
+                    }
+                    start++;
+                }
+
+                if (start <= end && isListItemNode(itemsArray[end])) {
+                    if (!isListItemEmpty(itemsArray[end])) {
+                        break;
+                    }
+                    end--;
+                }
             }
 
-            if (listItems.length > 0) {
-                newChildren.push(contentNode.copy(Fragment.fromArray(listItems)));
+            if (start !== initialStart || end !== initialEnd) {
+                const pos = start > end ? [0, 1] : [start, end + 1];
+                result = contentNode.copy(Fragment.fromArray(itemsArray.slice(...pos)));
+                modified = true;
             }
-        } else {
-            newChildren.push(contentNode);
         }
+
+        newChildren.push(result);
     });
 
     return modified ? Fragment.fromArray(newChildren) : fragment;

src/utils/nodes.ts

@@ -60,3 +60,19 @@ export function getLastChildOfNode(node: Node | Fragment): NodeChild {
     const children = getChildrenOfNode(node);
     return children[children.length - 1];
 }
+
+export const isEmptyString = (node: Node) => {
+    if (!node.content.size) {
+        return true;
+    }
+
+    if (
+        node.childCount === 1 &&
+        node.child(0).type.name === 'text' &&
+        node.child(0).text?.trim() === ''
+    ) {
+        return true;
+    }
+
+    return false;
+};