bookforge-core 1.8.0

Core IR, segmentation, configuration, and progress types for BookForge.
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
124
125
126
127
128
129
130
131

use std::path::PathBuf;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct BookId(pub String);

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct SectionId(pub String);

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct BlockId(pub String);

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Book {
    pub source_path: Option<PathBuf>,
    pub id: BookId,
    pub format: BookFormat,
    pub metadata: Metadata,
    pub manifest: Vec<Resource>,
    pub spine: Vec<SpineItem>,
    pub sections: Vec<Section>,
    pub blocks: Vec<Block>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum BookFormat {
    Epub,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Metadata {
    pub title: Option<String>,
    pub creators: Vec<String>,
    pub language: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Resource {
    pub id: String,
    pub href: String,
    pub media_type: String,
    pub properties: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpineItem {
    pub idref: String,
    pub href: Option<String>,
    pub linear: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Section {
    pub id: SectionId,
    pub href: String,
    pub spine_index: usize,
    pub title: Option<String>,
    pub heading_level: Option<u8>,
    pub block_ids: Vec<BlockId>,
    pub prev: Option<SectionId>,
    pub next: Option<SectionId>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Block {
    pub id: BlockId,
    pub section_id: SectionId,
    pub kind: BlockKind,
    pub dom_path: DomPath,
    pub text_runs: Vec<TextRun>,
    pub inline_marks: Vec<InlineMark>,
    pub protected_spans: Vec<ProtectedSpan>,
    pub token_estimate: usize,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum BlockKind {
    Heading(u8),
    Paragraph,
    ListItem,
    Quote,
    TableCell,
    TableRow,
    Footnote,
    Caption,
    Code,
    Unknown,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DomPath(pub Vec<usize>);

/// Path component base for addressing text nodes. Element children are
/// indexed 0, 1, 2, ...; the N-th non-whitespace text node inside an
/// element is addressed as `TEXT_NODE_PATH_BASE + N` in the final path
/// component. The offset keeps text-node addresses from ever colliding
/// with element indices. Reader and writer must count the same set of
/// text nodes (non-whitespace after entity decoding) for paths to align.
pub const TEXT_NODE_PATH_BASE: usize = usize::MAX / 2;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TextRun {
    pub id: String,
    pub text: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InlineMark {
    pub id: String,
    pub kind: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProtectedSpan {
    pub kind: ProtectedSpanKind,
    pub text: String,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ProtectedSpanKind {
    Url,
    Email,
    Code,
    Math,
    Number,
    Filename,
    InternalAnchor,
    Citation,
    FootnoteReference,
}