ui-grid-core 0.1.9

Rust engine for ui-grid
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

use crate::models::{GridOptions, GridRow};

fn is_pagination_enabled(options: &GridOptions) -> bool {
    options.enable_pagination || options.pagination_page_size.unwrap_or_default() > 0
}

fn initial_page_size(options: &GridOptions) -> usize {
    options
        .pagination_page_size
        .or_else(|| options.pagination_page_sizes.first().copied())
        .unwrap_or(options.data.len())
}

pub fn get_effective_page_size(
    options: &GridOptions,
    page_size: usize,
    total_items: usize,
) -> usize {
    if !is_pagination_enabled(options) {
        return total_items;
    }

    let resolved_page_size = if page_size == 0 {
        initial_page_size(options)
    } else {
        page_size
    };

    if resolved_page_size == 0 {
        total_items
    } else {
        resolved_page_size
    }
}

pub fn get_total_pages_value(options: &GridOptions, total_items: usize, page_size: usize) -> usize {
    let effective_page_size = get_effective_page_size(options, page_size, total_items);
    if !is_pagination_enabled(options) || effective_page_size == 0 {
        return 1;
    }

    total_items.max(1).div_ceil(effective_page_size).max(1)
}

pub fn get_current_page_value(
    options: &GridOptions,
    current_page: usize,
    total_items: usize,
    page_size: usize,
) -> usize {
    current_page
        .max(1)
        .min(get_total_pages_value(options, total_items, page_size))
}

pub fn get_first_row_index_value(
    options: &GridOptions,
    current_page: usize,
    total_items: usize,
    page_size: usize,
) -> usize {
    if !is_pagination_enabled(options) || total_items == 0 || options.use_external_pagination {
        return 0;
    }

    (get_current_page_value(options, current_page, total_items, page_size) - 1)
        * get_effective_page_size(options, page_size, total_items)
}

pub fn get_last_row_index_value(
    options: &GridOptions,
    current_page: usize,
    total_items: usize,
    page_size: usize,
) -> usize {
    if total_items == 0 {
        return 0;
    }

    if !is_pagination_enabled(options) || options.use_external_pagination {
        return total_items - 1;
    }

    (get_first_row_index_value(options, current_page, total_items, page_size)
        + get_effective_page_size(options, page_size, total_items))
    .min(total_items)
        - 1
}

pub fn paginate_grid_rows(
    rows: &[GridRow],
    options: &GridOptions,
    current_page: usize,
    page_size: usize,
    total_items: usize,
) -> Vec<GridRow> {
    if !is_pagination_enabled(options) || options.use_external_pagination {
        return rows.to_vec();
    }

    let resolved_page_size = get_effective_page_size(options, page_size, total_items);
    let first_row = get_first_row_index_value(options, current_page, total_items, page_size);
    rows.iter()
        .skip(first_row)
        .take(resolved_page_size)
        .cloned()
        .collect()
}

pub fn is_virtualization_enabled(options: &GridOptions, item_count: usize) -> bool {
    options.enable_virtualization && item_count >= options.virtualization_threshold.unwrap_or(40)
}

pub fn seek_grid_page(page: usize, total_pages: usize) -> usize {
    page.max(1).min(total_pages.max(1))
}

pub fn resolve_grid_page_size(page_size: usize) -> Option<usize> {
    if page_size > 0 { Some(page_size) } else { None }
}