tauri-plugin-thermal-printer 1.3.2

Plugin for Tauri to send esc/pos commands to thermal_printer
Documentation 
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 crate::commands_esc_pos::text::code_page::CodePage;
use unicode_width::UnicodeWidthChar;

use super::accent_remover::accent_remover_bytes;
use super::encode::Encode;

#[derive(Debug, Clone)]
pub struct TextEncoder {
    encode: Encode,
    use_gbk: bool,
}

#[derive(Debug, Clone)]
pub(crate) struct EncodedChar {
    pub(crate) bytes: Vec<u8>,
    pub(crate) width: usize,
}

impl TextEncoder {
    pub fn from_code_page(code_page: &CodePage) -> Self {
        Self {
            encode: code_page.encode,
            use_gbk: code_page.use_gbk,
        }
    }

    pub fn encode_text(&self, text: &str) -> Result<Vec<u8>, String> {
        let mut output = Vec::with_capacity(text.len());

        for ch in text.chars() {
            output.extend_from_slice(&self.encode_char(ch)?.bytes);
        }

        Ok(output)
    }

    pub(crate) fn encode_char(&self, ch: char) -> Result<EncodedChar, String> {
        match self.encode.encoding() {
            Some(encoding) => self.encode_with_encoding(ch, encoding),
            None => self.encode_accent_remover(ch),
        }
    }

    fn encode_accent_remover(&self, ch: char) -> Result<EncodedChar, String> {
        if let Some(mapped) = accent_remover_bytes(ch) {
            return Ok(multi_byte_char(mapped));
        }

        if ch.is_ascii() {
            return Ok(single_byte_char(ch as u8));
        }

        self.encode_with_optional_gbk(ch)
    }

    fn encode_with_encoding(
        &self,
        ch: char,
        encoding: &'static encoding_rs::Encoding,
    ) -> Result<EncodedChar, String> {
        let value = ch.to_string();
        let (encoded, _, had_errors) = encoding.encode(&value);

        if had_errors {
            return self.encode_with_optional_gbk(ch);
        }

        Ok(EncodedChar {
            bytes: encoded.into_owned(),
            width: display_width(ch),
        })
    }

    fn encode_with_optional_gbk(&self, ch: char) -> Result<EncodedChar, String> {
        if !self.use_gbk {
            return Ok(passthrough_char(ch));
        }

        encode_with_gbk(ch)
    }
}

fn single_byte_char(byte: u8) -> EncodedChar {
    EncodedChar {
        bytes: vec![byte],
        width: 1,
    }
}

fn multi_byte_char(bytes: &'static [u8]) -> EncodedChar {
    EncodedChar {
        bytes: bytes.to_vec(),
        width: bytes.len(),
    }
}

fn encode_with_gbk(ch: char) -> Result<EncodedChar, String> {
    let value = ch.to_string();
    let (encoded, _, had_errors) = encoding_rs::GBK.encode(&value);

    if had_errors {
        return Ok(passthrough_char(ch));
    }

    Ok(EncodedChar {
        bytes: encoded.into_owned(),
        width: display_width(ch),
    })
}

fn passthrough_char(ch: char) -> EncodedChar {
    EncodedChar {
        bytes: ch.to_string().into_bytes(),
        width: display_width(ch),
    }
}

fn display_width(ch: char) -> usize {
    UnicodeWidthChar::width_cjk(ch)
        .or_else(|| UnicodeWidthChar::width(ch))
        .unwrap_or(1)
        .max(1)
}