fix(Lists): enable tight lists by default to eliminate unnecessary spacing (#826)

Author: makhnatkin

src/extensions/markdown/Lists/Lists.test.ts

@@ -25,9 +25,9 @@ const {doc, p, li, ul, ol} = builders<'doc' | 'p' | 'li' | 'ul' | 'ol'>(schema,
 const {same} = createMarkupChecker({parser, serializer});
 
 describe('Lists extension', () => {
-    it('should parse bullet list', () => {
+    it('should parse bullet list (tight)', () => {
         same(
-            '* one\n\n* two',
+            '* one\n* two',
             doc(
                 ul(
                     {[ListsAttr.Markup]: '*'},
@@ -38,21 +38,47 @@ describe('Lists extension', () => {
         );
     });
 
-    it('should parse ordered list with dots', () => {
+    it('should parse bullet list (non tight)', () => {
+        same(
+            '* one\n\n* two',
+            doc(
+                ul(
+                    {[ListsAttr.Markup]: '*', [ListsAttr.Tight]: false},
+                    li({[ListsAttr.Markup]: '*'}, p('one')),
+                    li({[ListsAttr.Markup]: '*'}, p('two')),
+                ),
+            ),
+        );
+    });
+
+    it('should parse ordered list with dots (tight)', () => {
+        same(
+            '1. one\n2. two',
+            doc(
+                ol(
+                    li({[ListsAttr.Markup]: '.'}, p('one')),
+                    li({[ListsAttr.Markup]: '.'}, p('two')),
+                ),
+            ),
+        );
+    });
+
+    it('should parse ordered list with dots (non tight)', () => {
         same(
             '1. one\n\n2. two',
             doc(
                 ol(
+                    {[ListsAttr.Tight]: false},
                     li({[ListsAttr.Markup]: '.'}, p('one')),
                     li({[ListsAttr.Markup]: '.'}, p('two')),
                 ),
             ),
         );
     });
 
-    it('should parse ordered list with parenthesis', () => {
+    it('should parse ordered list with parenthesis (tight)', () => {
         same(
-            '1) one\n\n2) two',
+            '1) one\n2) two',
             doc(
                 ol(
                     {[ListsAttr.Markup]: ')'},
@@ -63,6 +89,19 @@ describe('Lists extension', () => {
         );
     });
 
+    it('should parse ordered list with parenthesis (non tight)', () => {
+        same(
+            '1) one\n\n2) two',
+            doc(
+                ol(
+                    {[ListsAttr.Markup]: ')', [ListsAttr.Tight]: false},
+                    li({[ListsAttr.Markup]: ')'}, p('one')),
+                    li({[ListsAttr.Markup]: ')'}, p('two')),
+                ),
+            ),
+        );
+    });
+
     it('should parse nested lists', () => {
         const markup = `
 - one
@@ -80,11 +119,12 @@ describe('Lists extension', () => {
             markup,
             doc(
                 ul(
-                    {[ListsAttr.Markup]: '-'},
+                    {[ListsAttr.Markup]: '-', [ListsAttr.Tight]: false},
                     li(
                         {[ListsAttr.Markup]: '-'},
                         p('one'),
                         ol(
+                            {[ListsAttr.Tight]: false},
                             li(
                                 {[ListsAttr.Markup]: '.'},
                                 p('two'),
@@ -110,15 +150,15 @@ describe('Lists extension', () => {
             '- + * 2. item',
             doc(
                 ul(
-                    {[ListsAttr.Markup]: '-'},
+                    {[ListsAttr.Markup]: '-', [ListsAttr.Tight]: false},
                     li(
                         {[ListsAttr.Markup]: '-'},
                         ul(
-                            {[ListsAttr.Markup]: '+'},
+                            {[ListsAttr.Markup]: '+', [ListsAttr.Tight]: false},
                             li(
                                 {[ListsAttr.Markup]: '+'},
                                 ul(
-                                    {[ListsAttr.Markup]: '*'},
+                                    {[ListsAttr.Markup]: '*', [ListsAttr.Tight]: false},
                                     li(
                                         {[ListsAttr.Markup]: '*'},
                                         ol(

src/extensions/markdown/Lists/ListsSpecs/schema.ts

@@ -5,7 +5,6 @@ import {ListNode, ListsAttr, Markup} from './const';
 export const schemaSpecs: Record<ListNode, NodeSpec> = {
     [ListNode.ListItem]: {
         attrs: {
-            [ListsAttr.Tight]: {default: false},
             [ListsAttr.Markup]: {default: null},
         },
         content: '(paragraph|block)+',
@@ -24,7 +23,7 @@ export const schemaSpecs: Record<ListNode, NodeSpec> = {
         content: `${ListNode.ListItem}+`,
         group: 'block',
         attrs: {
-            [ListsAttr.Tight]: {default: false},
+            [ListsAttr.Tight]: {default: true},
             [ListsAttr.Markup]: {default: Markup.bullet.default},
         },
         parseDOM: [
@@ -46,7 +45,7 @@ export const schemaSpecs: Record<ListNode, NodeSpec> = {
     [ListNode.OrderedList]: {
         attrs: {
             [ListsAttr.Order]: {default: 1},
-            [ListsAttr.Tight]: {default: false},
+            [ListsAttr.Tight]: {default: true},
             [ListsAttr.Markup]: {default: Markup.ordered.default},
         },
         content: `${ListNode.ListItem}+`,

src/extensions/markdown/Lists/plugins/MergeListsPlugin.test.ts

@@ -32,14 +32,16 @@ const nestedListsMarkup = `
 * Very easy!
 `;
 
-const orderedListMarkup = `
+const orderedListMarkup1 = `
 1. Create a list by starting a line with \`+\`, \`-\`, or \`*\`
 2. Sub-lists are made by indenting 2 spaces:
     1. Marker character change forces new list start:
     2. Ac tristique libero volutpat at
     3. Facilisis in pretium nisl aliquet
     4. Nulla volutpat aliquam velit
+`;
 
+const orderedListMarkup2 = `
 1. Very easy!
 2. Very easy!
 `;
@@ -106,16 +108,16 @@ describe('Lists extension', () => {
                 state: EditorState.create({schema, plugins: [mergeListsPlugin()]}),
             });
             view.dispatch(
-                view.state.tr.replaceWith(
-                    0,
-                    view.state.doc.nodeSize - 2,
-                    markupParser.parse(orderedListMarkup).content,
-                ),
+                view.state.tr.replaceWith(0, view.state.doc.nodeSize - 2, [
+                    markupParser.parse(orderedListMarkup1).firstChild!,
+                    markupParser.parse(orderedListMarkup2).firstChild!,
+                ]),
             );
             expect(view.state.doc).toMatchNode(
                 doc(
                     ol(
                         {
+                            [ListsAttr.Tight]: true,
                             [ListsAttr.Markup]: '.',
                         },
                         li(