feat(Clipboard): updated trimListItems logic, renamed to trimContent

makhnatkin · makhnatkin · commit 3f09b09fa142 · 2025-03-03T20:59:37.000+01:00
diff --git a/src/extensions/behavior/Clipboard/clipboard.ts b/src/extensions/behavior/Clipboard/clipboard.ts
@@ -11,12 +11,7 @@ import {serializeForClipboard} from '../../../utils/serialize-for-clipboard';
 import {BaseNode, pType} from '../../base/BaseSchema';
 
 import {isInsideCode} from './code';
-import {
-    DataTransferType,
-    extractTextContentFromHtml,
-    isIosSafariShare,
-    trimListItems,
-} from './utils';
+import {DataTransferType, extractTextContentFromHtml, isIosSafariShare, trimContent} from './utils';
 
 export type ClipboardPluginOptions = {
     logger: Logger2.ILogger;
@@ -322,7 +317,7 @@ function getCopyContent(state: EditorState): Slice {
         }
     } else {
         // trim empty list items
-        const trimedContent = trimListItems(slice.content);
+        const trimedContent = trimContent(slice.content);
         if (trimedContent !== slice.content) {
             slice = new Slice(trimedContent, 1, 1);
         }
diff --git a/src/extensions/behavior/Clipboard/utils.test.ts b/src/extensions/behavior/Clipboard/utils.test.ts
@@ -1,102 +1,195 @@
-import {Schema} from 'prosemirror-model';
 import {builders} from 'prosemirror-test-builder';
 
-import {trimListItems} from './utils';
-
-const schema = new Schema({
-    nodes: {
-        doc: {content: 'block+'},
-        text: {group: 'inline'},
-        paragraph: {group: 'block', content: 'text*', toDOM: () => ['p', 0]},
-        bullet_list: {content: 'list_item+', group: 'block'},
-        ordered_list: {content: 'list_item+', group: 'block'},
-        list_item: {content: 'block+'},
-    },
-    marks: {},
+import {findNotEmptyContentPosses, trimContent} from 'src/extensions/behavior/Clipboard/utils';
+import {CutAttr, CutNode, YfmCutSpecs} from 'src/extensions/yfm/YfmCut/YfmCutSpecs';
+
+import {DirectiveContext} from '../../../../tests/utils';
+import {ExtensionsManager} from '../../../core';
+import {BaseNode, BaseSchemaSpecs} from '../../base/specs';
+import {
+    BlockquoteSpecs,
+    ImageSpecs,
+    ItalicSpecs,
+    ListNode,
+    ListsSpecs,
+    blockquoteNodeName,
+    imageNodeName,
+    italicMarkName,
+} from '../../markdown/specs';
+
+const directiveContext = new DirectiveContext(undefined);
+
+function buildDeps() {
+    return new ExtensionsManager({
+        extensions: (builder) => {
+            builder.context.set('directiveSyntax', directiveContext);
+            builder
+                .use(BaseSchemaSpecs, {})
+                .use(ItalicSpecs)
+                .use(BlockquoteSpecs)
+                .use(YfmCutSpecs, {})
+                .use(ImageSpecs)
+                .use(ListsSpecs, {});
+        },
+    }).buildDeps();
+}
+
+const {schema} = buildDeps();
+
+const {doc, p, cut, cutTitle, cutContent, li, ul, ol, bq, img} = builders<
+    'doc' | 'p' | 'bq' | 'img' | 'cut' | 'cutTitle' | 'cutContent',
+    'i' | 'li' | 'ul' | 'ol'
+>(schema, {
+    doc: {nodeType: BaseNode.Doc},
+    p: {nodeType: BaseNode.Paragraph},
+    i: {markType: italicMarkName},
+    bq: {nodeType: blockquoteNodeName},
+    img: {nodeType: imageNodeName},
+    cut: {nodeType: CutNode.Cut},
+    cutTitle: {nodeType: CutNode.CutTitle},
+    cutContent: {nodeType: CutNode.CutContent},
+    li: {nodeType: ListNode.ListItem},
+    ul: {nodeType: ListNode.BulletList},
+    ol: {nodeType: ListNode.OrderedList},
 });
 
-const {doc, paragraph: p} = builders(schema);
-const bulletList = builders(schema)['bullet_list'];
-const orderedList = builders(schema)['ordered_list'];
-const listItem = builders(schema)['list_item'];
+describe('findNotEmptyContentPosses', () => {
+    it('identifies boundaries in a simple document', () => {
+        const fragment = doc(p('11'), p('22')).content;
+        expect(findNotEmptyContentPosses(fragment)).toEqual([0, 8, 0, 8]);
+    });
 
-describe('trimListItems', () => {
-    it('removes empty list items at the start and end of a bullet list', () => {
+    it('ignores empty paragraphs and detects valid content', () => {
+        const fragment = doc(p(), p('11'), p('22'), p()).content;
+        expect(findNotEmptyContentPosses(fragment)).toEqual([2, 10, 0, 12]);
+    });
+
+    it('handles custom nodes correctly', () => {
         const fragment = doc(
-            bulletList(listItem(), listItem(p('11')), listItem(p('22')), listItem()),
+            cut({[CutAttr.Markup]: '{%'}, cutTitle(''), cutContent(p())),
+            p('11'),
+            p('22'),
         ).content;
+        expect(findNotEmptyContentPosses(fragment)).toEqual([0, 16, 0, 16]);
+    });
+
+    it('skips empty list at start and finds content boundaries', () => {
+        const fragment = doc(ul(li(p(''))), p('11'), p('22')).content;
+        expect(findNotEmptyContentPosses(fragment)).toEqual([6, 14, 0, 14]);
+    });
+
+    it('skips empty list between paragraphs', () => {
+        const fragment = doc(p('11'), ul(li(p(''))), p('22')).content;
+        expect(findNotEmptyContentPosses(fragment)).toEqual([0, 14, 0, 14]);
+    });
+
+    it('ignores deeply nested empty lists', () => {
+        const fragment = doc(ul(li(p(''), ul(li(p(''))))), p('11'), p('22')).content;
+        expect(findNotEmptyContentPosses(fragment)).toEqual([12, 20, 0, 20]);
+    });
+
+    it('handles multiple empty lists before and after content', () => {
+        const fragment = doc(
+            ul(li(p(''), ul(li(p(''))))),
+            p('11'),
+            p('22'),
+            ul(li(p(''), ul(li(p(''))))),
+        ).content;
+        expect(findNotEmptyContentPosses(fragment)).toEqual([12, 20, 0, 32]);
+    });
+
+    it('identifies non-empty text inside a blockquote', () => {
+        const fragment = doc(bq(p('Quote text'))).content;
+        expect(findNotEmptyContentPosses(fragment)).toEqual([0, 14, 0, 14]);
+    });
 
-        const trimmedFragment = trimListItems(fragment);
+    it('identifies content inside an image node', () => {
+        const fragment = doc(p(), p(img({src: 'blob:test.jpg', alt: 'test.jpg'})), p()).content;
+        expect(findNotEmptyContentPosses(fragment)).toEqual([2, 5, 0, 7]);
+    });
+
+    it('handles a document with only empty elements', () => {
+        const fragment = doc(p(), ul(li(p(''))), ol(li(p('')))).content;
+        expect(findNotEmptyContentPosses(fragment)).toEqual([-1, -1, 0, 14]);
+    });
+
+    it('detects non-empty text after an empty section', () => {
+        const fragment = doc(p(), p(), p('Content')).content;
+        expect(findNotEmptyContentPosses(fragment)).toEqual([4, 13, 0, 13]);
+    });
+
+    it('detects non-empty content after multiple nested empty lists', () => {
+        const fragment = doc(ul(li(p(''), ul(li(p(''))))), ul(li(p(''))), p('Final')).content;
+        expect(findNotEmptyContentPosses(fragment)).toEqual([18, 25, 0, 25]);
+    });
+});
+
+describe('trimContent', () => {
+    it('removes empty list items at the start and end of a bullet list', () => {
+        const fragment = doc(ul(li(), li(p('11')), li(p('22')), li())).content;
+
+        const trimmedFragment = trimContent(fragment);
         expect(schema.nodes.doc.create(null, trimmedFragment)).toMatchNode(
-            doc(bulletList(listItem(p('11')), listItem(p('22')))),
+            doc(ul(li(p('11')), li(p('22')))),
         );
     });
 
     it('removes empty list items at the start and end of an ordered list', () => {
-        const fragment = doc(
-            orderedList(listItem(), listItem(p('11')), listItem(p('22')), listItem()),
-        ).content;
+        const fragment = doc(ol(li(), li(p('11')), li(p('22')), li())).content;
 
-        const trimmedFragment = trimListItems(fragment);
+        const trimmedFragment = trimContent(fragment);
         expect(schema.nodes.doc.create(null, trimmedFragment)).toMatchNode(
-            doc(orderedList(listItem(p('11')), listItem(p('22')))),
+            doc(ol(li(p('11')), li(p('22')))),
         );
     });
 
     it('removes only empty list items at the start and end, keeping empty ones in the middle', () => {
-        const fragment = doc(
-            bulletList(listItem(), listItem(p('11')), listItem(), listItem(p('22')), listItem()),
-        ).content;
+        const fragment = doc(ul(li(), li(p('11')), li(), li(p('22')), li())).content;
 
-        const trimmedFragment = trimListItems(fragment);
+        const trimmedFragment = trimContent(fragment);
         expect(schema.nodes.doc.create(null, trimmedFragment)).toMatchNode(
-            doc(bulletList(listItem(p('11')), listItem(), listItem(p('22')))),
+            doc(ul(li(p('11')), li(), li(p('22')))),
         );
     });
 
     it('does not modify a list with no empty items', () => {
-        const fragment = doc(bulletList(listItem(p('11')), listItem(p('22')))).content;
+        const fragment = doc(ul(li(p('11')), li(p('22')))).content;
 
-        const trimmedFragment = trimListItems(fragment);
+        const trimmedFragment = trimContent(fragment);
         expect(schema.nodes.doc.create(null, trimmedFragment)).toMatchNode(
-            doc(bulletList(listItem(p('11')), listItem(p('22')))),
+            doc(ul(li(p('11')), li(p('22')))),
         );
     });
 
     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 fragment = doc(ul(li(), li(), li())).content;
 
-        const trimmedFragment = trimListItems(fragment);
-        expect(schema.nodes.doc.create(null, trimmedFragment)).toMatchNode(
-            doc(bulletList(listItem())),
-        );
+        const trimmedFragment = trimContent(fragment);
+        expect(schema.nodes.doc.create(null, trimmedFragment)).toMatchNode(doc(ul()));
     });
 
     it('correctly handles multiple lists in a single fragment', () => {
         const fragment = doc(
-            bulletList(listItem(), listItem(p('11')), listItem(), listItem(p('22')), listItem()),
-            orderedList(listItem(), listItem(p('A')), listItem(p('B')), listItem()),
+            ul(li(), li(p('11')), li(), li(p('22')), li()),
+            ol(li(), li(p('A')), li(p('B')), li()),
         ).content;
 
-        const trimmedFragment = trimListItems(fragment);
+        const trimmedFragment = trimContent(fragment);
         expect(schema.nodes.doc.create(null, trimmedFragment)).toMatchNode(
-            doc(
-                bulletList(listItem(p('11')), listItem(), listItem(p('22'))),
-                orderedList(listItem(p('A')), listItem(p('B'))),
-            ),
+            doc(ul(li(p('11')), li(), li(p('22')), li()), ol(li(), li(p('A')), li(p('B')))),
         );
     });
 
     it('does not modify paragraphs and other nodes outside lists', () => {
         const fragment = doc(
             p('Some text'),
-            bulletList(listItem(), listItem(p('11')), listItem(p('22')), listItem()),
+            ul(li(), li(p('11')), li(p('22')), li()),
             p('More text'),
         ).content;
 
-        const trimmedFragment = trimListItems(fragment);
+        const trimmedFragment = trimContent(fragment);
         expect(schema.nodes.doc.create(null, trimmedFragment)).toMatchNode(
-            doc(p('Some text'), bulletList(listItem(p('11')), listItem(p('22'))), p('More text')),
+            doc(p('Some text'), ul(li(), li(p('11')), li(p('22')), li()), p('More text')),
         );
     });
 });
diff --git a/src/extensions/behavior/Clipboard/utils.ts b/src/extensions/behavior/Clipboard/utils.ts
@@ -1,4 +1,4 @@
-import {Fragment, type Node} from 'prosemirror-model';
+import type {Fragment} from 'prosemirror-model';
 
 import {isListItemNode, isListNode} from 'src/extensions/markdown/Lists/utils';
 import {isEmptyString} from 'src/utils';
@@ -62,59 +62,47 @@ 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) => {
-        let result = contentNode;
+export function findNotEmptyContentPosses(fragment: Fragment): [number, number, number, number] {
+    let firstNodePos = -1;
+    let lastNodePos = -1;
+    let firstNotEmptyNodePos = -1;
+    let lastNotEmptyNodePos = -1;
 
-        if (isListNode(contentNode)) {
-            const itemsArray: Node[] = Array.from(contentNode.content.content);
-            if (itemsArray.length === 0) {
-                return;
-            }
+    fragment.forEach((contentNode, offset) => {
+        if (firstNodePos === -1) {
+            firstNodePos = offset;
+        }
+        lastNodePos = offset + contentNode.nodeSize;
 
-            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 (!isEmptyString(contentNode)) {
+            if (isListNode(contentNode) || isListItemNode(contentNode)) {
+                const [start, end] = findNotEmptyContentPosses(contentNode.content);
+                if (firstNotEmptyNodePos === -1 && start !== -1) {
+                    firstNotEmptyNodePos = offset + start;
                 }
-
-                if (start <= end && isListItemNode(itemsArray[end])) {
-                    if (!isListItemEmpty(itemsArray[end])) {
-                        break;
-                    }
-                    end--;
+                if (end !== -1) {
+                    lastNotEmptyNodePos = offset + end;
                 }
-            }
-
-            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 {
+                if (firstNotEmptyNodePos === -1) {
+                    firstNotEmptyNodePos = offset;
+                }
+                lastNotEmptyNodePos = offset + contentNode.nodeSize;
             }
         }
-
-        newChildren.push(result);
     });
 
-    return modified ? Fragment.fromArray(newChildren) : fragment;
+    return [firstNotEmptyNodePos, lastNotEmptyNodePos, firstNodePos, lastNodePos];
+}
+
+export function trimContent(fragment: Fragment): Fragment {
+    const [notEmptyStart, notEmptyEnd, start, end] = findNotEmptyContentPosses(fragment);
+
+    if (notEmptyStart === start && notEmptyEnd === end) {
+        return fragment;
+    } else if (notEmptyStart === -1 && notEmptyEnd === -1) {
+        return fragment.cut(0, 1);
+    }
+
+    return fragment.cut(notEmptyStart + 1, notEmptyEnd + 1);
 }
diff --git a/src/utils/nodes.ts b/src/utils/nodes.ts
@@ -62,7 +62,7 @@ export function getLastChildOfNode(node: Node | Fragment): NodeChild {
 }
 
 export const isEmptyString = (node: Node) => {
-    if (!node.content.size) {
+    if (node.type.name === 'paragraph' && !node.content.size) {
         return true;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ export function getLastChildOfNode(node: Node \| Fragment): NodeChild {`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`export const isEmptyString = (node: Node) => {`
`65`		`- if (!node.content.size) {`
	`65`	`+ if (node.type.name === 'paragraph' && !node.content.size) {`
`66`	`66`	`return true;`
`67`	`67`	`}`
`68`	`68`