prosemirror-diff/registry.ts at master · pubpub/prosemirror-diff · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
import { compareArray } from './compareArray';
import { compareInline } from './compareInline';
import { createCompareObjects } from './compareObjects';
import { compareByIdentity } from './compareByIdentity';
import { decorateText, decorateNodeWithContent } from './decorate';
import { resolveText, resolveElementWithContent } from './resolve';
import { Registry } from './types';

const contentWeight = (element, weight) =>
    element.content
        ? 2 + 0.8 * element.content.map(weight).reduce((a, b) => a + b)
        : 2;

const contentNode = contentComparator => ({
    diff: {
        compare: createCompareObjects({
            content: contentComparator,
        }),
        weight: contentWeight,
    },
    render: {
        resolve: resolveElementWithContent,
        decorate: decorateNodeWithContent,
    },
});

const leafNode = {
    diff: {
        compare: createCompareObjects({}),
        weight: () => 100,
    },
    render: {
        resolve: resolveElementWithContent,
        decorate: decorateNodeWithContent,
    },
};

export const baseRegistry = {
    doc: {
        diff: {
            compare: createCompareObjects({
                content: compareArray,
            }),
            weight: contentWeight,
        },
        render: {
            resolve: resolveElementWithContent,
            decorate: decorateNodeWithContent,
        },
    },
    paragraph: contentNode(compareInline),
    blockquote: contentNode(compareInline),
    horizontal_rule: leafNode,
    heading: {
        diff: {
            compare: createCompareObjects({
                attrs: {
                    level: compareByIdentity,
                },
                content: compareInline,
            }),
            weight: contentWeight,
        },
        render: {
            resolve: resolveElementWithContent,
            decorate: decorateNodeWithContent,
        },
    },
    bullet_list: contentNode(compareArray),
    ordered_list: contentNode(compareArray),
    code_block: contentNode(compareInline),
    hard_break: leafNode,
    list_item: contentNode(compareArray),
    text: {
        diff: {
            weight: element => element.text.length,
        },
        render: {
            resolve: resolveText,
            decorate: decorateText,
        },
    },
    none: leafNode,
    image: {
        diff: {
            compare: createCompareObjects({
                url: { default: null },
                size: { default: 50 }, // number as percentage
                align: { default: 'center' },
                caption: { default: '' },
            }),
            weight: () => 500,
        },
        render: {
            resolve: resolveElementWithContent,
            decorate: decorateNodeWithContent,
        },
    },
};

export const getTypeFromRegistry = (registry: Registry, type: string) => {
    if (!registry[type] || typeof registry[type] !== 'object') {
        throw new Error(
            `prosemirror-compare registry does not have an entry for ${type}`
        );
    }
    return registry[type];
};