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

use crate::{
    filtering::matches_grid_row_filters,
    grouping::build_grid_display_items,
    models::{BuildGridPipelineContext, PipelineResult},
    pagination::{is_virtualization_enabled, paginate_grid_rows},
    sorting::sort_grid_rows,
    tree::{build_grid_rows, filter_and_flatten_grid_tree_rows, is_tree_enabled},
};

#[cfg(not(target_arch = "wasm32"))]
fn pipeline_started_at() -> std::time::Instant {
    std::time::Instant::now()
}

#[cfg(target_arch = "wasm32")]
fn pipeline_started_at() {}

#[cfg(not(target_arch = "wasm32"))]
fn pipeline_elapsed_ms(started_at: std::time::Instant) -> f64 {
    started_at.elapsed().as_secs_f64() * 1000.0
}

#[cfg(target_arch = "wasm32")]
fn pipeline_elapsed_ms(_: ()) -> f64 {
    0.0
}

pub fn build_grid_pipeline(context: &BuildGridPipelineContext) -> PipelineResult {
    let started_at = pipeline_started_at();
    let rows = build_grid_rows(
        &context.options,
        context.row_size,
        &context.hidden_row_reasons,
        &context.expanded_rows,
    );

    let visible_rows = if is_tree_enabled(&context.options) {
        filter_and_flatten_grid_tree_rows(
            &rows,
            &context.columns,
            &context.options,
            &context.active_filters,
            &context.expanded_tree_rows,
            &context.sort_state,
        )
    } else {
        let filtered = rows
            .into_iter()
            .filter_map(|row| {
                let mut current = row.clone();
                matches_grid_row_filters(
                    &mut current,
                    &context.columns,
                    &context.options,
                    &context.active_filters,
                )
                .then_some(current)
            })
            .collect::<Vec<_>>();

        sort_grid_rows(
            &filtered,
            &context.columns,
            &context.options,
            &context.sort_state,
        )
    };

    let total_items = if context.options.use_external_pagination {
        context.options.total_items.unwrap_or(visible_rows.len())
    } else {
        visible_rows.len()
    };

    let paged_rows = paginate_grid_rows(
        &visible_rows,
        &context.options,
        context.current_page,
        context.page_size,
        total_items,
    );

    let display_items = build_grid_display_items(
        &paged_rows,
        &context.columns,
        &context.options,
        &context.group_by_columns,
        &context.collapsed_groups,
    );

    PipelineResult {
        visible_rows: paged_rows,
        virtualization_enabled: is_virtualization_enabled(&context.options, display_items.len()),
        display_items,
        pipeline_ms: pipeline_elapsed_ms(started_at),
        total_items,
    }
}