quill-delta-to-html/test/grouper/ListNester.test.ts

Converts Quill's delta ops to HTML

import 'mocha';
import * as assert from "assert";

import { Grouper } from './../../src/grouper/Grouper';
import { ListNester } from './../../src/grouper/ListNester';
import { DeltaInsertOp } from './../../src/DeltaInsertOp';
import { ListGroup, ListItem, InlineGroup, BlockGroup 
} from './../../src/grouper/group-types';
import {ListType} from './../../src/value-types';

describe('ListNester', function () {

    describe('nest()', function () {
        it('should not nest different types of lists', function () {
            var ops = [
                new DeltaInsertOp("ordered list 1 item 1"),
                new DeltaInsertOp("\n", { list: ListType.Ordered }),
                new DeltaInsertOp("bullet list 1 item 1"),
                new DeltaInsertOp("\n", { list: ListType.Bullet }),
                new DeltaInsertOp("bullet list 1 item 2"),
                new DeltaInsertOp("\n", { list: ListType.Bullet }),
                new DeltaInsertOp("haha"),
                new DeltaInsertOp("\n"),
                new DeltaInsertOp("\n", { list: ListType.Bullet }),
            ];

            var groups = Grouper.pairOpsWithTheirBlock(ops);
            var nester = new ListNester();
            var act = nester.nest(groups);
            //console.log(JSON.stringify(act, null, 3));
            assert.deepEqual(act, [
                new ListGroup([new ListItem(<BlockGroup>groups[0]) ]),
                new ListGroup([new ListItem(<BlockGroup>groups[1]), 
                    new ListItem(<BlockGroup>groups[2])]),
                new InlineGroup([ops[6], ops[7]]),
                new ListGroup([new ListItem(new BlockGroup(ops[8], []))])
            ]);
        });

        it('should nest if lists are same and later ones have higher indent', function () {
            var ops = [
                new DeltaInsertOp("item 1"),
                new DeltaInsertOp("\n", { list: ListType.Ordered }),
                new DeltaInsertOp("item 1a"),
                new DeltaInsertOp("\n", { list: ListType.Ordered, indent: 1 }),
                new DeltaInsertOp("item 1a-i"),
                new DeltaInsertOp("\n", { list: ListType.Ordered, indent: 3 }),
                new DeltaInsertOp("item 1b"),
                new DeltaInsertOp("\n", { list: ListType.Ordered, indent: 1 }),
                new DeltaInsertOp("item 2",  ),
                new DeltaInsertOp("\n", { list: ListType.Ordered }),
                new DeltaInsertOp("haha"),
                new DeltaInsertOp("\n"),
                new DeltaInsertOp("\n", { list: ListType.Ordered, indent:5 }),
                new DeltaInsertOp("\n", { list: ListType.Bullet, indent:4 }),
            ]
            var pairs = Grouper.pairOpsWithTheirBlock(ops);
            
            var nester = new ListNester();
            var act = nester.nest(pairs);
            //console.log(JSON.stringify( act, null, 4));
             

            var l1b = new ListItem(<BlockGroup>pairs[3])
            var lai = new ListGroup([new ListItem(<BlockGroup>pairs[2])]);
            var l1a = new ListGroup([new ListItem(<BlockGroup>pairs[1], lai)]);
            
            var li1 = new ListGroup([new ListItem(<BlockGroup>pairs[0]) ]);
            li1.items[0].innerList =new ListGroup(l1a.items.concat(l1b));
            var li2 = new ListGroup([ new ListItem(<BlockGroup>pairs[4])])
            //console.log(JSON.stringify(act, null, 3));
            assert.deepEqual(act, [ new ListGroup(li1.items.concat(li2.items)), 
                
                new InlineGroup([ops[10], ops[11]]), 
                new ListGroup([ new ListItem(new BlockGroup(ops[12], []))]),
                new ListGroup([ new ListItem(new BlockGroup(ops[13], []))])
                ]);
        });

    });
});