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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use fxhash::FxHashMap;
use loro_common::InternalString;

use super::{ExpandType, TextStyleInfoFlag};

#[derive(Debug, Default, Clone)]
pub struct StyleConfigMap {
    map: FxHashMap<InternalString, StyleConfig>,
}

impl StyleConfigMap {
    pub fn new() -> Self {
        Self {
            map: FxHashMap::default(),
        }
    }

    pub fn insert(&mut self, key: InternalString, value: StyleConfig) {
        if key.contains(':') {
            panic!("style key should not contain ':'");
        }

        self.map.insert(key, value);
    }

    pub fn get(&self, key: &InternalString) -> Option<&StyleConfig> {
        self.map.get(key)
    }

    pub fn get_style_flag(&self, key: &InternalString) -> Option<TextStyleInfoFlag> {
        self._get_style_flag(key, false)
    }

    pub fn get_style_flag_for_unmark(&self, key: &InternalString) -> Option<TextStyleInfoFlag> {
        self._get_style_flag(key, true)
    }

    fn _get_style_flag(&self, key: &InternalString, is_del: bool) -> Option<TextStyleInfoFlag> {
        let f = |x: &StyleConfig| {
            TextStyleInfoFlag::new(if is_del { x.expand.reverse() } else { x.expand })
        };
        if let Some(index) = key.find(':') {
            let key = key[..index].into();
            self.map.get(&key).map(f)
        } else {
            self.map.get(key).map(f)
        }
    }

    pub fn default_rich_text_config() -> Self {
        let mut map = Self {
            map: FxHashMap::default(),
        };

        map.map.insert(
            "bold".into(),
            StyleConfig {
                expand: ExpandType::After,
            },
        );

        map.map.insert(
            "italic".into(),
            StyleConfig {
                expand: ExpandType::After,
            },
        );

        map.map.insert(
            "underline".into(),
            StyleConfig {
                expand: ExpandType::After,
            },
        );

        map.map.insert(
            "link".into(),
            StyleConfig {
                expand: ExpandType::None,
            },
        );

        map.map.insert(
            "highlight".into(),
            StyleConfig {
                expand: ExpandType::None,
            },
        );

        map.map.insert(
            "comment".into(),
            StyleConfig {
                expand: ExpandType::None,
            },
        );

        map
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct StyleConfig {
    pub expand: ExpandType,
}

impl StyleConfig {
    pub fn new() -> Self {
        Self {
            expand: ExpandType::None,
        }
    }

    pub fn expand(mut self, expand: ExpandType) -> Self {
        self.expand = expand;
        self
    }
}

impl Default for StyleConfig {
    fn default() -> Self {
        Self::new()
    }
}