mtcute/packages/markdown-parser/tests/markdown-parser.spec.ts

import { expect } from 'chai'
import Long from 'long'
import { describe, it } from 'mocha'

import { FormattedString, MessageEntity, tl } from '@mtcute/client'
import { isPresent } from '@mtcute/client/utils'

import { MarkdownMessageEntityParser, md } from '../src'

const createEntity = <T extends tl.TypeMessageEntity['_']>(
    type: T,
    offset: number,
    length: number,
    additional?: Omit<tl.FindByName<tl.TypeMessageEntity, T>, '_' | 'offset' | 'length'>,
): tl.TypeMessageEntity => {
    return {
        _: type,
        offset,
        length,
        ...(additional ?? {}),
    } as tl.TypeMessageEntity // idc really, its not that important
}

const createEntities = (entities: tl.TypeMessageEntity[]): MessageEntity[] => {
    return entities.map((it) => MessageEntity._parse(it)).filter(isPresent)
}

describe('MarkdownMessageEntityParser', () => {
    const parser = new MarkdownMessageEntityParser()

    describe('unparse', () => {
        const test = (
            text: string,
            entities: tl.TypeMessageEntity[],
            expected: string | string[],
            _parser = parser,
        ): void => {
            const result = _parser.unparse(text, createEntities(entities))

            if (Array.isArray(expected)) {
                expect(expected).to.include(result)
            } else {
                expect(result).eq(expected)
            }
        }

        it('should return the same text if there are no entities or text', () => {
            test('', [], '')
            test('some text', [], 'some text')
        })

        it('should handle bold, italic, underline, strikethrough and spoiler', () => {
            test(
                'plain bold italic underline strikethrough spoiler plain',
                [
                    createEntity('messageEntityBold', 6, 4),
                    createEntity('messageEntityItalic', 11, 6),
                    createEntity('messageEntityUnderline', 18, 9),
                    createEntity('messageEntityStrike', 28, 13),
                    createEntity('messageEntitySpoiler', 42, 7),
                ],
                'plain **bold** __italic__ --underline-- ~~strikethrough~~ ||spoiler|| plain',
            )
        })

        it('should handle code and pre', () => {
            test(
                'plain code pre __ignored__ plain',
                [
                    createEntity('messageEntityCode', 6, 4),
                    createEntity('messageEntityPre', 11, 3),
                    createEntity('messageEntityCode', 15, 11),
                ],
                'plain `code` ```\npre\n``` `\\_\\_ignored\\_\\_` plain',
            )
        })

        it('should handle links and text mentions', () => {
            test(
                'plain https://google.com google @durov Pavel Durov mail@mail.ru plain',
                [
                    createEntity('messageEntityTextUrl', 25, 6, {
                        url: 'https://google.com',
                    }),
                    createEntity('messageEntityMention', 32, 6),
                    createEntity('messageEntityMentionName', 39, 11, {
                        userId: 36265675,
                    }),
                    createEntity('messageEntityEmail', 51, 12),
                ],
                'plain https://google.com [google](https://google.com) @durov [Pavel Durov](tg://user?id=36265675) mail@mail.ru plain',
            )
        })

        it('should handle language in pre', () => {
            test(
                'plain console.log("Hello, world!") some code plain',
                [
                    createEntity('messageEntityPre', 6, 28, {
                        language: 'javascript',
                    }),
                    createEntity('messageEntityPre', 35, 9, { language: '' }),
                ],
                'plain ```javascript\nconsole.log("Hello, world!")\n``` ```\nsome code\n``` plain',
            )
        })

        it('should support entities on the edges', () => {
            test(
                'Hello, world',
                [createEntity('messageEntityBold', 0, 5), createEntity('messageEntityBold', 7, 5)],
                '**Hello**, **world**',
            )
        })

        it('should clamp out-of-range entities', () => {
            test(
                'Hello, world',
                [createEntity('messageEntityBold', -2, 7), createEntity('messageEntityBold', 7, 10)],
                '**Hello**, **world**',
            )
        })

        it('should ignore entities outside the length', () => {
            test('Hello, world', [createEntity('messageEntityBold', 50, 5)], 'Hello, world')
        })

        it('should support entities followed by each other', () => {
            test(
                'plain Hello, world plain',
                [createEntity('messageEntityBold', 6, 6), createEntity('messageEntityItalic', 12, 6)],
                [
                    'plain **Hello,**__ world__ plain',
                    // not the most obvious order, but who cares :D
                    // we support this syntax in parse()
                    'plain **Hello,__** world__ plain',
                ],
            )
        })

        it('should support nested entities', () => {
            test(
                'Welcome to the gym zone!',
                [createEntity('messageEntityItalic', 0, 24), createEntity('messageEntityBold', 15, 8)],
                '__Welcome to the **gym zone**!__',
            )
        })

        it('should support nested entities with the same edges', () => {
            test(
                'Welcome to the gym zone!',
                [createEntity('messageEntityItalic', 0, 24), createEntity('messageEntityBold', 15, 9)],
                ['__Welcome to the **gym zone!**__', '__Welcome to the **gym zone!__**'],
            )
            test(
                'Welcome to the gym zone!',
                [createEntity('messageEntityBold', 0, 24), createEntity('messageEntityItalic', 15, 9)],
                ['**Welcome to the __gym zone!__**', '**Welcome to the __gym zone!**__'],
            )
            test(
                'Welcome to the gym zone!',
                [createEntity('messageEntityItalic', 0, 24), createEntity('messageEntityBold', 0, 7)],
                ['__**Welcome** to the gym zone!__', '**__Welcome** to the gym zone!__'],
            )
            test(
                'Welcome to the gym zone!',
                [createEntity('messageEntityItalic', 0, 24), createEntity('messageEntityBold', 0, 24)],
                [
                    '__**Welcome to the gym zone!**__',
                    '__**Welcome to the gym zone!__**',
                    '**__Welcome to the gym zone!**__',
                    '**__Welcome to the gym zone!__**',
                ],
            )
        })

        it('should support overlapping entities', () => {
            test(
                'Welcome to the gym zone!',
                [createEntity('messageEntityItalic', 0, 14), createEntity('messageEntityBold', 8, 10)],
                '__Welcome **to the__ gym** zone!',
            )
            test(
                'plain bold bold!italic bold!italic!underline underline plain',
                [
                    createEntity('messageEntityBold', 6, 38),
                    createEntity('messageEntityItalic', 11, 33),
                    createEntity('messageEntityUnderline', 23, 31),
                ],
                [
                    'plain **bold __bold!italic --bold!italic!underline**__ underline-- plain',
                    'plain **bold __bold!italic --bold!italic!underline__** underline-- plain',
                ],
            )
            test(
                'plain bold bold!italic bold!italic!underline italic!underline underline plain',
                [
                    createEntity('messageEntityBold', 6, 38),
                    createEntity('messageEntityItalic', 11, 50),
                    createEntity('messageEntityUnderline', 23, 48),
                ],
                'plain **bold __bold!italic --bold!italic!underline** italic!underline__ underline-- plain',
            )
        })

        it('should properly handle emojis', () => {
            test(
                "best flower: 🌸. don't you even doubt it.",
                [
                    createEntity('messageEntityItalic', 0, 11),
                    createEntity('messageEntityBold', 13, 2),
                    createEntity('messageEntityItalic', 17, 5),
                ],
                "__best flower__: **🌸**. __don't__ you even doubt it.",
            )
        })

        it('should escape reserved symbols', () => {
            test(
                '* ** *** _ __ ___ - -- --- ~ ~~ ~~~ [ [[ ` `` ``` ```` \\ \\\\',
                [createEntity('messageEntityItalic', 9, 8)],
                // holy shit
                '/* /*/* /*/*/* __/_ /_/_ /_/_/___ /- /-/- /-/-/- /~ /~/~ /~/~/~ /[ /[/[ /` /`/` /`/`/` /`/`/`/` // ////'
                    // so we don't have to escape every single backslash lol
                    .replace(/\//g, '\\'),
            )
            test(
                '* ** *** _ __ ___ - -- ---',
                [
                    // here we test that the order of the entities does not matter
                    createEntity('messageEntityItalic', 18, 4),
                    createEntity('messageEntityItalic', 9, 8),
                ],
                '/* /*/* /*/*/* __/_ /_/_ /_/_/___ __/- /-/-__ /-/-/-'.replace(/\//g, '\\'),
            )
        })
    })

    describe('parse', () => {
        const test = (
            texts: string | string[],
            expectedEntities: tl.TypeMessageEntity[],
            expectedText: string,
        ): void => {
            if (!Array.isArray(texts)) texts = [texts]

            for (const text of texts) {
                const [_text, entities] = parser.parse(text)
                expect(_text).eql(expectedText)
                expect(entities).eql(expectedEntities)
            }
        }

        it('should handle bold, italic, underline, spoiler and strikethrough', () => {
            test(
                'plain **bold** __italic__ --underline-- ~~strikethrough~~ ||spoiler|| plain',
                [
                    createEntity('messageEntityBold', 6, 4),
                    createEntity('messageEntityItalic', 11, 6),
                    createEntity('messageEntityUnderline', 18, 9),
                    createEntity('messageEntityStrike', 28, 13),
                    createEntity('messageEntitySpoiler', 42, 7),
                ],
                'plain bold italic underline strikethrough spoiler plain',
            )
        })

        it('should handle code and pre', () => {
            test(
                [
                    'plain `code` ```\npre\n``` `__ignored__` plain',
                    'plain `code` ```\npre\n``` `\\_\\_ignored\\_\\_` plain',
                    'plain `code` ```\npre``` `\\_\\_ignored\\_\\_` plain',
                ],
                [
                    createEntity('messageEntityCode', 6, 4),
                    createEntity('messageEntityPre', 11, 3, { language: '' }),
                    createEntity('messageEntityCode', 15, 11),
                ],
                'plain code pre __ignored__ plain',
            )

            test(
                'plain ```\npre with ` and ``\n``` plain',
                [createEntity('messageEntityPre', 6, 17, { language: '' })],
                'plain pre with ` and `` plain',
            )

            test(
                'plain ```\npre with \n`\n and \n``\nend\n``` plain',
                [createEntity('messageEntityPre', 6, 24, { language: '' })],
                'plain pre with \n`\n and \n``\nend plain',
            )
        })

        it('should handle links and text mentions', () => {
            test(
                'plain https://google.com [google](https://google.com) @durov [Pavel Durov](tg://user?id=36265675) plain',
                [
                    createEntity('messageEntityTextUrl', 25, 6, {
                        url: 'https://google.com',
                    }),
                    createEntity('messageEntityMentionName', 39, 11, {
                        userId: 36265675,
                    }),
                ],
                'plain https://google.com google @durov Pavel Durov plain',
            )

            test(
                '[user](tg://user?id=1234567&hash=aabbccddaabbccdd)',
                [
                    createEntity('inputMessageEntityMentionName', 0, 4, {
                        userId: {
                            _: 'inputUser',
                            userId: 1234567,
                            accessHash: Long.fromString('aabbccddaabbccdd', 16),
                        },
                    }),
                ],
                'user',
            )
        })

        it('should handle language in pre', () => {
            test(
                'plain ```javascript\nconsole.log("Hello, world!")\n``` ```\nsome code\n``` plain',
                [
                    createEntity('messageEntityPre', 6, 28, {
                        language: 'javascript',
                    }),
                    createEntity('messageEntityPre', 35, 9, { language: '' }),
                ],
                'plain console.log("Hello, world!") some code plain',
            )
        })

        it('should support entities on the edges', () => {
            test(
                '**Hello**, **world**',
                [createEntity('messageEntityBold', 0, 5), createEntity('messageEntityBold', 7, 5)],
                'Hello, world',
            )
        })

        it('should return empty array if there are no entities', () => {
            test('Hello, world', [], 'Hello, world')
        })

        it('should support overlapping entities', () => {
            test(
                '__Welcome **to the__ gym** zone!',
                [createEntity('messageEntityItalic', 0, 14), createEntity('messageEntityBold', 8, 10)],
                'Welcome to the gym zone!',
            )

            // resulting order will depend on the order in which the closing ** or __ are passed,
            // thus we use separate tests
            test(
                'plain **bold __bold-italic --bold-italic-underline**__ underline-- plain',
                [
                    createEntity('messageEntityBold', 6, 38),
                    createEntity('messageEntityItalic', 11, 33),
                    createEntity('messageEntityUnderline', 23, 31),
                ],
                'plain bold bold-italic bold-italic-underline underline plain',
            )
            test(
                'plain **bold __bold-italic --bold-italic-underline__** underline-- plain',
                [
                    createEntity('messageEntityItalic', 11, 33),
                    createEntity('messageEntityBold', 6, 38),
                    createEntity('messageEntityUnderline', 23, 31),
                ],
                'plain bold bold-italic bold-italic-underline underline plain',
            )

            test(
                'plain **bold __bold-italic --bold-italic-underline** italic-underline__ underline-- plain',
                [
                    createEntity('messageEntityBold', 6, 38),
                    createEntity('messageEntityItalic', 11, 50),
                    createEntity('messageEntityUnderline', 23, 48),
                ],
                'plain bold bold-italic bold-italic-underline italic-underline underline plain',
            )
        })

        it('should support entities followed by each other', () => {
            test(
                ['plain **Hello,**__ world__ plain', 'plain **Hello,__** world__ plain'],
                [createEntity('messageEntityBold', 6, 6), createEntity('messageEntityItalic', 12, 6)],
                'plain Hello, world plain',
            )
        })

        it('should support nested entities', () => {
            test(
                '__Welcome to the **gym zone**!__',
                [createEntity('messageEntityBold', 15, 8), createEntity('messageEntityItalic', 0, 24)],
                'Welcome to the gym zone!',
            )

            test(
                'plain [__google__](https://google.com) plain',
                [
                    createEntity('messageEntityItalic', 6, 6),
                    createEntity('messageEntityTextUrl', 6, 6, {
                        url: 'https://google.com',
                    }),
                ],
                'plain google plain',
            )
            test(
                'plain [plain __google__ plain](https://google.com) plain',
                [
                    createEntity('messageEntityItalic', 12, 6),
                    createEntity('messageEntityTextUrl', 6, 18, {
                        url: 'https://google.com',
                    }),
                ],
                'plain plain google plain plain',
            )
        })

        it('should support nested entities with the same edges', () => {
            // again, order of the entities depends on which closing tag goes first.
            test(
                '__Welcome to the **gym zone!**__',
                [createEntity('messageEntityBold', 15, 9), createEntity('messageEntityItalic', 0, 24)],
                'Welcome to the gym zone!',
            )
            test(
                '__Welcome to the **gym zone!__**',
                [createEntity('messageEntityItalic', 0, 24), createEntity('messageEntityBold', 15, 9)],
                'Welcome to the gym zone!',
            )

            test(
                '**Welcome to the __gym zone!__**',
                [createEntity('messageEntityItalic', 15, 9), createEntity('messageEntityBold', 0, 24)],
                'Welcome to the gym zone!',
            )
            test(
                '**Welcome to the __gym zone!**__',
                [createEntity('messageEntityBold', 0, 24), createEntity('messageEntityItalic', 15, 9)],
                'Welcome to the gym zone!',
            )

            test(
                ['__**Welcome** to the gym zone!__', '**__Welcome** to the gym zone!__'],
                [createEntity('messageEntityBold', 0, 7), createEntity('messageEntityItalic', 0, 24)],
                'Welcome to the gym zone!',
            )

            test(
                ['__**Welcome to the gym zone!**__', '**__Welcome to the gym zone!**__'],
                [createEntity('messageEntityBold', 0, 24), createEntity('messageEntityItalic', 0, 24)],
                'Welcome to the gym zone!',
            )
            test(
                ['__**Welcome to the gym zone!__**', '**__Welcome to the gym zone!__**'],
                [createEntity('messageEntityItalic', 0, 24), createEntity('messageEntityBold', 0, 24)],
                'Welcome to the gym zone!',
            )
        })

        it('should properly handle emojis', () => {
            test(
                "__best flower__: **🌸**. __don't__ you even doubt it.",
                [
                    createEntity('messageEntityItalic', 0, 11),
                    createEntity('messageEntityBold', 13, 2),
                    createEntity('messageEntityItalic', 17, 5),
                ],
                "best flower: 🌸. don't you even doubt it.",
            )
        })

        it('should handle escaped reserved symbols', () => {
            test(
                '/* /*/* /*/*/* __/_ /_/_ /_/_/___ /- /-/- /-/-/- /~ /~/~ /~/~/~ /[ /[/[ /` /`/` /`/`/` /`/`/`/` // ////'.replace(
                    /\//g,
                    '\\',
                ),
                [createEntity('messageEntityItalic', 9, 8)],
                '* ** *** _ __ ___ - -- --- ~ ~~ ~~~ [ [[ ` `` ``` ```` \\ \\\\',
            )
            test(
                '/* /*/* /*/*/* __/_ /_/_ /_/_/___ __/- /-/-__ /-/-/-'.replace(/\//g, '\\'),
                [createEntity('messageEntityItalic', 9, 8), createEntity('messageEntityItalic', 18, 4)],
                '* ** *** _ __ ___ - -- ---',
            )
        })

        it('should ignore empty urls', () => {
            test('[link]() [link]', [], 'link [link]')
        })

        it('should ignore unclosed tags', () => {
            test('plain ```\npre closed with single backtick`', [], 'plain pre closed with single backtick`')
            test('plain ```\npre closed with single backtick\n`', [], 'plain pre closed with single backtick\n`')

            test('plain ```\npre closed with double backticks`', [], 'plain pre closed with double backticks`')
            test('plain ```\npre closed with double backticks\n`', [], 'plain pre closed with double backticks\n`')

            test('plain __italic but unclosed', [], 'plain italic but unclosed')
            test('plain __italic and **also bold but both unclosed', [], 'plain italic and also bold but both unclosed')
            test(
                'plain __italic and **also bold but italic closed__',
                [createEntity('messageEntityItalic', 6, 38)],
                'plain italic and also bold but italic closed',
            )
            test(
                'plain __italic and **also bold but bold closed**',
                [createEntity('messageEntityBold', 17, 25)],
                'plain italic and also bold but bold closed',
            )
        })

        describe('malformed input', () => {
            const testThrows = (input: string) => expect(() => parser.parse(input)).throws(Error)

            it('should throw an error on malformed links', () => {
                testThrows('plain [link](https://google.com but unclosed')
            })

            it('should throw an error on malformed pres', () => {
                testThrows('plain ```pre without linebreaks```')
                testThrows('plain ``` pre without linebreaks but with spaces instead ```')
            })
        })
    })

    describe('template', () => {
        it('should work as a tagged template literal', () => {
            const unsafeString = '__[]__'

            expect(md`${unsafeString}`.value).eq('\\_\\_\\[\\]\\_\\_')
            expect(md`${unsafeString} **text**`.value).eq('\\_\\_\\[\\]\\_\\_ **text**')
            expect(md`**text** ${unsafeString}`.value).eq('**text** \\_\\_\\[\\]\\_\\_')
            expect(md`**${unsafeString}**`.value).eq('**\\_\\_\\[\\]\\_\\_**')
        })

        it('should skip with FormattedString', () => {
            const unsafeString2 = '__[]__'
            const unsafeString = new FormattedString('__[]__')

            expect(md`${unsafeString}`.value).eq('__[]__')
            expect(md`${unsafeString} ${unsafeString2}`.value).eq('__[]__ \\_\\_\\[\\]\\_\\_')
            expect(md`${unsafeString} **text**`.value).eq('__[]__ **text**')
            expect(md`**text** ${unsafeString}`.value).eq('**text** __[]__')
            expect(md`**${unsafeString} ${unsafeString2}**`.value).eq('**__[]__ \\_\\_\\[\\]\\_\\_**')
        })

        it('should error with incompatible FormattedString', () => {
            const unsafeString = new FormattedString('<&>', 'markdown')
            const unsafeString2 = new FormattedString('<&>', 'some-other-mode')

            expect(() => md`${unsafeString}`.value).not.throw(Error)
            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
            // @ts-expect-error
            expect(() => md`${unsafeString2}`.value).throw(Error)
        })
    })
})