iris-reader 1.0.0

A terminal-native viewer for documents, structured data, images, PDFs, databases, and stdin.
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

pub mod markdown;
pub mod text;

use std::path::Path;

use ratatui::text::Line;

use crate::{
    image::ImageManager,
    input::{Input, InputKind},
    search::{SearchMatch, SearchMatcher},
    theme::Theme,
};

pub type NodeId = usize;
pub type HeadingId = NodeId;

#[derive(Debug, Clone)]
pub struct RenderedLine {
    pub line: Line<'static>,
    pub plain: String,
    pub source_id: Option<NodeId>,
}

impl RenderedLine {
    pub fn empty() -> Self {
        Self {
            line: Line::default(),
            plain: String::new(),
            source_id: None,
        }
    }
}

#[derive(Debug, Clone)]
pub struct RenderedHeading {
    pub id: HeadingId,
    pub level: u8,
    pub title: String,
    pub slug: String,
    pub line: usize,
}

#[derive(Debug, Clone)]
pub struct RenderedLink {
    pub source_id: NodeId,
    pub destination: String,
    pub line: usize,
    pub start_column: usize,
    pub end_column: usize,
}

#[derive(Debug, Clone)]
pub struct RenderedImage {
    pub source_id: NodeId,
    pub source: String,
    pub alt: String,
    pub destination: Option<String>,
    pub line: usize,
    pub column: usize,
    pub height: u16,
}

#[derive(Debug, Clone, Default)]
pub struct RenderedDocument {
    pub lines: Vec<RenderedLine>,
    pub headings: Vec<RenderedHeading>,
    pub links: Vec<RenderedLink>,
    pub images: Vec<RenderedImage>,
    pub max_width: usize,
}

impl RenderedDocument {
    pub fn finish(mut self) -> Self {
        self.max_width = self
            .lines
            .iter()
            .map(|line| unicode_width::UnicodeWidthStr::width(line.plain.as_str()))
            .max()
            .unwrap_or(0);
        self
    }
}

pub enum ViewDocument {
    Text(text::TextDocument),
    Markdown(markdown::Document),
}

impl ViewDocument {
    pub fn from_input(input: &Input) -> Self {
        match input.kind {
            InputKind::Text => Self::Text(text::TextDocument::new(&input.content)),
            InputKind::Markdown => Self::Markdown(markdown::parse(&input.content)),
        }
    }

    pub fn render(
        &self,
        width: u16,
        theme: &Theme,
        wrap: bool,
        tab_width: usize,
        images: &mut ImageManager,
        base_dir: Option<&Path>,
    ) -> RenderedDocument {
        match self {
            Self::Text(document) => text::render(document, width, theme, wrap, tab_width),
            Self::Markdown(document) => {
                markdown::render(document, width, theme, wrap, tab_width, images, base_dir)
            }
        }
    }

    pub fn search(&self, matcher: &SearchMatcher) -> Vec<SearchMatch> {
        match self {
            Self::Text(document) => document.search(matcher),
            Self::Markdown(document) => document.search(matcher),
        }
    }

    pub fn is_markdown(&self) -> bool {
        matches!(self, Self::Markdown(_))
    }
}