Crate ag_grid_rs

Rust bindings for the AG Grid JavaScript library.

With this crate, one is able to use the AG Grid datatable library within a Wasm context in Rust.

A simple example demonstrating server-side data fetching using Yew and related dependencies is as follows:

use ag_grid_rs::{
    gridoptions::{DataSourceBuilder, RowModelType},
    ColumnDef, GridOptions, ToJsValue,
};
use gloo_net::http::Request;
use serde::Deserialize;
use wasm_bindgen::JsCast;
use web_sys::HtmlElement;
use yew::prelude::*;

#[function_component(About)]
pub fn about() -> Html {
    use_effect_with_deps(
        |_| {
            // Get the element to which you want to attach the grid
            let grid_div = get_element_by_id("grid-div");

            // Define your columns
            let field_names = vec!["athlete", "age", "country", "year"];
            let cols = field_names
                .iter()
                .map(|name| ColumnDef::new(name).sortable(true))
                .collect();

            // Create your datasource, including a closure that will retunr rows from the
            // server
            let data_source = DataSourceBuilder::new(|params| async move {
                // `params` contains information from AG Grid about which rows to get, how to
                // sort the data, etc
                let data_url = "https://www.ag-grid.com/example-assets/olympic-winners.json";
                let rows = gloo_net::http::Request::get(data_url)
                    .send()
                    .await?
                    .json::<Vec<JsonData>>()
                    .await?;

                Ok((rows, None))
            })
            .build();

            let grid = GridOptions::<JsonData>::new()
                .column_defs(cols)
                .row_model_type(RowModelType::Infinite)
                .datasource(data_source)
                .build(grid_div);

            // `grid` now provides a handle to the grid and column APIs
            || ()
        },
        (),
    );

    html! {
        <>
            <div id="grid-div" class="ag-theme-alpine" style="height: 500px"/>
        </>
    }
}

#[derive(ToJsValue, Deserialize)]
struct JsonData {
    athlete: String,
    age: Option<usize>,
    country: String,
    year: usize,
}

fn get_element_by_id(id: &str) -> HtmlElement {
    web_sys::window()
        .expect("unable to get window object")
        .document()
        .expect("unable to get document object")
        .get_element_by_id(id)
        .expect("unable to find grid-div")
        .dyn_into::<HtmlElement>()
        .unwrap()
}

Re-exports

pub use column::ColumnApi;

pub use column::ColumnDef;

pub use grid::Grid;

pub use grid::GridApi;

pub use gridoptions::GridOptions;

Modules

callbacks

A collection of parameter types passed to callback functions.

column

Types pertaining to the grid columns.

convert

Access to the ToJsValue trait for converting types into wasm_bindgen::JsValues.

filter

Types pertaining to grid filtering.

grid

Types pertaining to the Grid itself.

gridoptions

Types pertaining to defining and constructing a Grid.

sort

Types pertaining to grid sorting.

Derive Macros

ToJsValue

Automatically derive the ToJsValue trait to enable the annotated type to be serialized to a wasm_bindgen::JsValue.