29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/examples/tailwind/README.md:
--------------------------------------------------------------------------------
1 | ### A simple table example with just local data stored as `Vec` Uses the Tailwind class provider.
2 |
3 | To make this example work, you must download / fork the whole repo because this is in the Cargo.toml: `leptos-struct-table = { path = "../.." }`.
4 |
5 | The way Tailwind works, is to scan the classes in the code. Due to this it is
6 | recommended to copy the file `src/class_providers/tailwind.rs` into your project as done in this example.
7 |
8 | If you don't have it installed already, install [Trunk](https://trunkrs.dev/) and [Tailwind](https://tailwindcss.com/docs/installation)
9 | as well as the wasm32-unknown-unknown target:
10 |
11 | ```bash
12 | cargo install trunk
13 | npm install -D tailwindcss
14 | rustup target add wasm32-unknown-unknown
15 | ```
16 |
17 | Then, open two terminals. In the first one, run:
18 |
19 | ```
20 | npx tailwindcss -i ./input.css -o ./style/output.css --watch
21 | ```
22 |
23 | In the second one, run:
24 |
25 | ```bash
26 | trunk serve --open
27 | ```
--------------------------------------------------------------------------------
/examples/selectable/README.md:
--------------------------------------------------------------------------------
1 | ### A table example with selectable rows and data that is stored as `Vec` Uses the Tailwind class provider.
2 |
3 | To make this example work, you must download / fork the whole repo because this is in the Cargo.toml: `leptos-struct-table = { path = "../.." }`.
4 |
5 | The way Tailwind works, is to scan the classes in the code. Due to this it is
6 | recommended to copy the file `src/class_providers/tailwind.rs` into your project as done in this example.
7 |
8 | If you don't have it installed already, install [Trunk](https://trunkrs.dev/) and [Tailwind](https://tailwindcss.com/docs/installation)
9 | as well as the wasm32-unknown-unknown target:
10 |
11 | ```bash
12 | cargo install trunk
13 | npm install -D tailwindcss
14 | rustup target add wasm32-unknown-unknown
15 | ```
16 |
17 | Then, open two terminals. In the first one, run:
18 |
19 | ```
20 | npx tailwindcss -i ./input.css -o ./style/output.css --watch
21 | ```
22 |
23 | In the second one, run:
24 |
25 | ```bash
26 | trunk serve --open
27 | ```
--------------------------------------------------------------------------------
/examples/editable/README.md:
--------------------------------------------------------------------------------
1 | ### A table example with editable cells and data that is stored as `Vec`.
2 |
3 | To make this example work, you must download / fork the whole repo because this is in the Cargo.toml: `leptos-struct-table = { path = "../.." }`.
4 |
5 | #### Uses the Tailwind class provider.
6 |
7 | The way Tailwind works, is to scan the classes in the code. Due to this it is
8 | recommended to copy the file `src/class_providers/tailwind.rs` into your project as done in this example.
9 |
10 | If you don't have it installed already, install [Trunk](https://trunkrs.dev/) and [Tailwind](https://tailwindcss.com/docs/installation)
11 | as well as the wasm32-unknown-unknown target:
12 |
13 | ```bash
14 | cargo install trunk
15 | npm install -D tailwindcss
16 | rustup target add wasm32-unknown-unknown
17 | ```
18 |
19 | Then, open two terminals. In the first one, run:
20 |
21 | ```
22 | npx tailwindcss -i ./input.css -o ./style/output.css --watch
23 | ```
24 |
25 | In the second one, run:
26 |
27 | ```bash
28 | trunk serve --open
29 | ```
--------------------------------------------------------------------------------
/examples/editable/src/renderer.rs:
--------------------------------------------------------------------------------
1 | use crate::Book;
2 | use leptos::prelude::*;
3 |
4 | /// A renderer that shows an tag and emits the `on_change` event when the is changed.
5 | #[component]
6 | #[allow(unused_variables)]
7 | pub fn InputCellRenderer(
8 | /// The class attribute for the cell element. Generated by the classes provider.
9 | class: String,
10 | /// The value to display.
11 | value: Signal,
12 | /// Event handler called when the cell is changed.
13 | row: RwSignal,
14 | /// The index of the column. Starts at 0.
15 | index: usize,
16 | ) -> impl IntoView {
17 | let on_change = move |evt| {
18 | let value = event_target_value(&evt);
19 |
20 | let mut row = row.write();
21 |
22 | match index {
23 | 1 => row.title = value,
24 | 2 => row.author = value,
25 | _ => unreachable!(),
26 | }
27 | };
28 |
29 | view! {
30 |
31 |
32 |
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/src/rust_decimal.rs:
--------------------------------------------------------------------------------
1 | //! Support for [::rust_decimal] crate.
2 | use crate::*;
3 | use ::rust_decimal::Decimal;
4 | use leptos::prelude::*;
5 |
6 | #[derive(Clone, Default)]
7 | pub struct DecimalNumberRenderOptions {
8 | /// Specifies the number of digits to display after the decimal point
9 | pub precision: Option,
10 | }
11 | /// Implementation for [`Decimal`] to work with the [`TableRow`] derive and the [`DefaultTableCellRenderer`]
12 | /// ```
13 | /// # use leptos_struct_table::*;
14 | /// # use leptos::prelude::*;
15 | /// # use ::rust_decimal::Decimal;
16 | /// #[derive(TableRow, Clone)]
17 | /// #[table]
18 | /// struct SomeStruct {
19 | /// #[table(format(precision = 2usize))]
20 | /// my_field: Decimal
21 | /// }
22 | /// ```
23 | impl CellValue for Decimal {
24 | type RenderOptions = DecimalNumberRenderOptions;
25 | fn render_value(self, options: Self::RenderOptions) -> impl IntoView {
26 | if let Some(value) = options.precision.as_ref() {
27 | format!("{:.value$}", self)
28 | } else {
29 | self.to_string()
30 | }
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/src/selection.rs:
--------------------------------------------------------------------------------
1 | use leptos::prelude::*;
2 | use std::collections::HashSet;
3 |
4 | /// Type of selection together with the `RwSignal` to hold the selection
5 | #[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
6 | pub enum Selection {
7 | /// No selection possible (the default).
8 | #[default]
9 | None,
10 |
11 | /// Allow only one row to be selected at a time. `None` if no rows are selected.
12 | /// `Some()` if a row is selected.
13 | Single(RwSignal>),
14 |
15 | /// Allow multiple rows to be selected at a time. Each entry in the `Vec`
16 | /// is the index of a selected row.
17 | Multiple(RwSignal>),
18 | }
19 |
20 | impl Selection {
21 | /// Clear the selection
22 | pub fn clear(&self) {
23 | match self {
24 | Selection::None => {}
25 | Selection::Single(selected_index) => {
26 | selected_index.set(None);
27 | }
28 | Selection::Multiple(selected_indices) => {
29 | selected_indices.write().clear();
30 | }
31 | }
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LICENSE-MIT:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2023 Synphonyte
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/src/components/mod.rs:
--------------------------------------------------------------------------------
1 | mod cell;
2 | mod renderer_fn;
3 | mod row;
4 | mod table_content;
5 | mod tbody;
6 | mod thead;
7 |
8 | pub use cell::*;
9 | pub use row::*;
10 | pub use table_content::*;
11 | pub use tbody::*;
12 | pub use thead::*;
13 |
14 | #[macro_export]
15 | macro_rules! wrapper_render_fn {
16 | (
17 | #[$doc_name:meta]
18 | $name:ident,
19 | $tag:ident,
20 | $(#[$additional_doc:meta])*
21 | ) => {
22 | /// Default
23 | #[$doc_name]
24 | /// renderer. Please note that this is **NOT** a `#[component]`.
25 | ///
26 | /// # Arguments
27 | ///
28 | /// * `content` - The content of the renderer. It's like the children of this view.
29 | /// * `class` - The class attribute that is passed to the root element
30 | $(#[$additional_doc])*
31 | #[allow(non_snake_case)]
32 | pub fn $name(content: AnyView, class: Signal) -> impl IntoView {
33 | view! {
34 | <$tag class=class>
35 | {content}
36 |
37 | }
38 | }
39 | };
40 | }
41 |
--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
1 | name: Continuous Integration
2 |
3 | on:
4 | pull_request:
5 | branches:
6 | - main
7 | paths:
8 | - "**"
9 | - "!/*.md"
10 | - "!/**.md"
11 |
12 | concurrency:
13 | group: "${{ github.workflow }} @ ${{ github.event.pull_request.head.label || github.head_ref || github.ref }}"
14 | cancel-in-progress: true
15 |
16 | jobs:
17 | integrity:
18 | name: Integrity Checks on Rust ${{ matrix.toolchain }}
19 | runs-on: ubuntu-latest
20 | timeout-minutes: 15
21 | strategy:
22 | matrix:
23 | toolchain:
24 | - stable
25 | - nightly
26 |
27 | steps:
28 | - name: Checkout
29 | uses: actions/checkout@v6
30 |
31 | - name: Setup Rust
32 | uses: dtolnay/rust-toolchain@master
33 | with:
34 | toolchain: ${{ matrix.toolchain }}
35 | targets: wasm32-unknown-unknown
36 | components: clippy, rustfmt
37 |
38 | - name: Setup Rust Cache
39 | uses: Swatinem/rust-cache@v2
40 |
41 | - name: Build
42 | run: cargo build
43 |
44 | - name: Format
45 | run: cargo fmt --check
46 |
47 | - name: Clippy
48 | run: cargo clippy -- -D warnings
49 |
--------------------------------------------------------------------------------
/examples/paginated_rest_datasource/src/models.rs:
--------------------------------------------------------------------------------
1 | use crate::renderer::ObjectLinkTableCellRenderer;
2 | use leptos_struct_table::{FieldGetter, TableRow};
3 | use serde::{Deserialize, Serialize};
4 |
5 | #[derive(PartialEq, PartialOrd, Clone, Debug, Default)]
6 | pub struct Link {
7 | pub text: String,
8 | pub href: String,
9 | }
10 |
11 | #[derive(TableRow, Serialize, Deserialize, Clone, Debug)]
12 | #[table(sortable)]
13 | pub struct Brewery {
14 | #[table(skip)]
15 | pub id: String,
16 |
17 | pub name: String,
18 |
19 | pub city: String,
20 |
21 | pub country: String,
22 |
23 | #[table(skip)]
24 | pub website_url: Option,
25 |
26 | #[serde(skip_deserializing)]
27 | #[table(title = "Link", renderer = "ObjectLinkTableCellRenderer")]
28 | pub link: FieldGetter,
29 | }
30 |
31 | impl Brewery {
32 | pub fn link(&self) -> Link {
33 | Link {
34 | text: self.website_url.clone().unwrap_or("".to_string()),
35 | href: self.website_url.clone().unwrap_or("".to_string()),
36 | }
37 | }
38 | }
39 |
40 | #[derive(Deserialize, Debug)]
41 | pub struct MetaResponse {
42 | pub total: String,
43 | pub page: String,
44 | pub per_page: String,
45 | }
--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "leptos-struct-table"
3 | version = "0.16.0"
4 | edition = "2024"
5 | categories = ["gui", "web-programming", "wasm"]
6 | description = "Generate a complete batteries included leptos data table component from a struct definition."
7 | exclude = ["examples/", "tests/"]
8 | keywords = ["leptos", "table", "data-sheet", "data-grid"]
9 | license = "MIT OR Apache-2.0"
10 | readme = "README.md"
11 | repository = "https://github.com/Synphonyte/leptos-struct-table"
12 |
13 | [package.metadata."docs.rs"]
14 | all-features = true
15 |
16 | [dependencies]
17 | leptos = { version = "0.8" }
18 | leptos-struct-table-macro = { version = "0.13.0" }
19 | leptos-use = { version = "0.17", default-features = false, features = [
20 | "element",
21 | "use_debounce_fn",
22 | "use_element_size",
23 | "use_scroll",
24 | ] }
25 | rust_decimal = { version = "1", optional = true }
26 | chrono = { version = "0.4", optional = true }
27 | send_wrapper = "0.6"
28 | serde = "1"
29 | time = { version = "0.3", optional = true, features = ["formatting"] }
30 | uuid = { version = "1", optional = true, features = [] }
31 | web-sys = { version = "0.3", features = ["DomRect", "Element"] }
32 | wasm-bindgen = "0.2"
33 |
34 | [features]
35 | chrono = ["dep:chrono"]
36 | uuid = ["dep:uuid"]
37 | rust_decimal = ["dep:rust_decimal"]
38 | time = ["dep:time"]
39 | i18n = ["leptos-struct-table-macro/i18n"]
40 |
--------------------------------------------------------------------------------
/examples/serverfn_sqlx/src/main.rs:
--------------------------------------------------------------------------------
1 | #[cfg(feature = "ssr")]
2 | #[tokio::main]
3 | async fn main() {
4 | use axum::Router;
5 | use leptos::config::get_configuration;
6 | use leptos_axum::{generate_route_list, LeptosRoutes};
7 | use serverfn_sqlx::{shell, App};
8 |
9 | serverfn_sqlx::database::init_db().await;
10 |
11 | let conf = get_configuration(Some("Cargo.toml")).unwrap();
12 | let leptos_options = conf.leptos_options;
13 | let addr = leptos_options.site_addr;
14 | let routes = generate_route_list(App);
15 |
16 | // build our application with a route
17 | let app = Router::new()
18 | .leptos_routes(&leptos_options, routes, {
19 | let leptos_options = leptos_options.clone();
20 | move || shell(leptos_options.clone())
21 | })
22 | .fallback(leptos_axum::file_and_error_handler(shell))
23 | .with_state(leptos_options);
24 |
25 | let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
26 | println!("listening on http://{}", &addr);
27 | axum::serve(listener, app.into_make_service())
28 | .await
29 | .unwrap();
30 | }
31 |
32 | #[cfg(not(feature = "ssr"))]
33 | pub fn main() {
34 | // no client-side main function
35 | // unless we want this to work with e.g., Trunk for a purely client-side app
36 | // see lib.rs for hydration function instead
37 | }
38 |
--------------------------------------------------------------------------------
/src/sorting.rs:
--------------------------------------------------------------------------------
1 | use crate::{ColumnSort, TableHeadEvent};
2 | use std::collections::VecDeque;
3 |
4 | /// Sorting mode
5 | #[derive(PartialEq, Eq, Clone, Copy, Debug, Default)]
6 | pub enum SortingMode {
7 | /// The table can be sorted by only one single column at a time
8 | SingleColumn,
9 |
10 | /// The table can be sorted by multiple columns ordered by priority
11 | #[default]
12 | MultiColumn,
13 | }
14 |
15 | impl SortingMode {
16 | pub fn update_sorting_from_event(
17 | &self,
18 | sorting: &mut VecDeque<(usize, ColumnSort)>,
19 | event: TableHeadEvent,
20 | ) {
21 | let (i, &(_, mut sort)) = sorting
22 | .iter()
23 | .enumerate()
24 | .find(|(_, (col_index, _))| col_index == &event.index)
25 | .unwrap_or((0, &(event.index, ColumnSort::None)));
26 |
27 | if i == 0 || sort == ColumnSort::None {
28 | sort = match sort {
29 | ColumnSort::None => ColumnSort::Ascending,
30 | ColumnSort::Ascending => ColumnSort::Descending,
31 | ColumnSort::Descending => ColumnSort::None,
32 | };
33 | }
34 |
35 | *sorting = sorting
36 | .clone()
37 | .into_iter()
38 | .filter(|(col_index, sort)| *col_index != event.index && *sort != ColumnSort::None)
39 | .collect();
40 |
41 | if sort != ColumnSort::None {
42 | sorting.push_front((event.index, sort));
43 | }
44 |
45 | if self == &SortingMode::SingleColumn {
46 | sorting.truncate(1);
47 | }
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/examples/bootstrap/src/main.rs:
--------------------------------------------------------------------------------
1 | use ::chrono::NaiveDate;
2 | use leptos::prelude::*;
3 | use leptos_struct_table::*;
4 |
5 | // This generates the component BookTable
6 | #[derive(TableRow, Clone)]
7 | #[table(
8 | sortable,
9 | classes_provider = "BootstrapClassesPreset",
10 | impl_vec_data_provider
11 | )]
12 | pub struct Book {
13 | pub id: u32,
14 | pub title: String,
15 | pub author: String,
16 | pub publish_date: NaiveDate,
17 | }
18 |
19 | fn main() {
20 | _ = console_log::init_with_level(log::Level::Debug);
21 | console_error_panic_hook::set_once();
22 |
23 | mount_to_body(|| {
24 | let rows = vec![
25 | Book {
26 | id: 1,
27 | title: "The Great Gatsby".to_string(),
28 | author: "F. Scott Fitzgerald".to_string(),
29 | publish_date: NaiveDate::from_ymd_opt(1925, 4, 10).unwrap(),
30 | },
31 | Book {
32 | id: 2,
33 | title: "The Grapes of Wrath".to_string(),
34 | author: "John Steinbeck".to_string(),
35 | publish_date: NaiveDate::from_ymd_opt(1939, 4, 14).unwrap(),
36 | },
37 | Book {
38 | id: 3,
39 | title: "Nineteen Eighty-Four".to_string(),
40 | author: "George Orwell".to_string(),
41 | publish_date: NaiveDate::from_ymd_opt(1949, 6, 8).unwrap(),
42 | },
43 | Book {
44 | id: 4,
45 | title: "Ulysses".to_string(),
46 | author: "James Joyce".to_string(),
47 | publish_date: NaiveDate::from_ymd_opt(1922, 2, 2).unwrap(),
48 | },
49 | ];
50 |
51 | view! {
52 |
67 | }
68 | })
69 | }
70 |
--------------------------------------------------------------------------------
/src/components/row.rs:
--------------------------------------------------------------------------------
1 | use crate::EventHandler;
2 | use crate::table_row::TableRow;
3 | use leptos::prelude::*;
4 |
5 | /// The default table row renderer. Uses the `
` element. Please note that this
6 | /// is **NOT** a `#[component]`.
7 | #[allow(unused_variables)]
8 | pub fn DefaultTableRowRenderer(
9 | // The class attribute for the row element. Generated by the classes provider.
10 | class: Signal,
11 | // The row to render.
12 | row: RwSignal,
13 | // The index of the row. Starts at 0 for the first body row.
14 | index: usize,
15 | // The selected state of the row. True, when the row is selected.
16 | selected: Signal,
17 | // Event handler callback when this row is selected
18 | on_select: EventHandler,
19 | ) -> impl IntoView
20 | where
21 | Row: TableRow + 'static,
22 | {
23 | view! {
24 |
25 | {TableRow::render_row(row, index)}
26 |
27 | }
28 | }
29 |
30 | /// The default row placeholder renderer which is just a div that is set to the
31 | /// appropriate height. This is used in place of rows that are not shown
32 | /// before and after the currently visible rows.
33 | pub fn DefaultRowPlaceholderRenderer(height: Signal) -> impl IntoView {
34 | view! {
}
35 | }
36 |
37 | /// The default error row renderer which just displays the error message when
38 | /// a row fails to load, i.e. when [`TableDataProvider::get_rows`] returns an `Err(..)`.
39 | #[allow(unused_variables)]
40 | pub fn DefaultErrorRowRenderer(err: String, index: usize, col_count: usize) -> impl IntoView {
41 | view! {
22 | /// ```
23 | #[component]
24 | pub fn DefaultTableHeaderCellRenderer(
25 | /// The class attribute for the head element. Generated by the classes provider.
26 | #[prop(into)]
27 | class: Signal,
28 | /// The class attribute for the inner element. Generated by the classes provider.
29 | #[prop(into)]
30 | inner_class: String,
31 | /// The index of the column. Starts at 0 for the first column. The order of the columns is the same as the order of the fields in the struct.
32 | index: usize,
33 | /// The sort priority of the column. `None` if the column is not sorted. `0` means the column is the primary sort column.
34 | #[prop(into)]
35 | sort_priority: Signal>,
36 | /// The sort direction of the column. See [`ColumnSort`].
37 | #[prop(into)]
38 | sort_direction: Signal,
39 | /// The event handler for the click event. Has to be called with [`TableHeadEvent`].
40 | on_click: F,
41 | children: Children,
42 | ) -> impl IntoView
43 | where
44 | F: Fn(TableHeadEvent) + 'static,
45 | {
46 | let style = default_th_sorting_style(sort_priority, sort_direction);
47 |
48 | view! {
49 |
103 | }
104 | }
105 |
--------------------------------------------------------------------------------
/src/class_providers/mod.rs:
--------------------------------------------------------------------------------
1 | mod bootstrap;
2 | mod tailwind;
3 |
4 | use crate::ColumnSort;
5 | pub use bootstrap::*;
6 | pub use tailwind::*;
7 |
8 | /// A trait for providing classes for the table.
9 | pub trait TableClassesProvider {
10 | /// Create a new instance of the class provider.
11 | fn new() -> Self;
12 |
13 | /// Get the class attribute for the thead.
14 | /// The `prop_class` parameter contains the classes specified in the
15 | /// `thead_class` prop of the [`TableContent`] component.
16 | fn thead(&self, prop_class: &str) -> String {
17 | prop_class.to_string()
18 | }
19 |
20 | /// Get the classes for the thead row.
21 | /// The `prop_class` parameter contains the classes specified in the
22 | /// `thead_row_class` prop of the [`TableContent`] component.
23 | fn thead_row(&self, prop_class: &str) -> String {
24 | prop_class.to_string()
25 | }
26 |
27 | /// Get the classes for the thead cells.
28 | /// The `sort` parameter contains the sort state of the column.
29 | /// The `macro_class` parameter contains the classes specified in the `head_class` macro attribute of the field.
30 | fn thead_cell(&self, sort: ColumnSort, macro_class: &str) -> String {
31 | format!("{} {}", sort.as_class(), macro_class)
32 | }
33 |
34 | /// Get the classes for the thead cells' inner element.
35 | fn thead_cell_inner(&self) -> String {
36 | "".to_string()
37 | }
38 |
39 | /// Get the classes for the tbody.
40 | /// The `prop_class` parameter contains the classes specified in the
41 | /// `tbody_class` prop of the [`TableContent`] component.
42 | fn tbody(&self, prop_class: &str) -> String {
43 | prop_class.to_string()
44 | }
45 |
46 | #[allow(unused_variables)]
47 | /// Get the classes for the body rows.
48 | /// The `row_index` parameter contains the index of the row. The first row has index 0.
49 | /// The `selected` parameter indicates whether the row is selected.
50 | /// The `prop_class` parameter contains the classes specified in the `row_class`
51 | /// prop of the [`TableContent`] component.
52 | fn row(&self, row_index: usize, selected: bool, prop_class: &str) -> String {
53 | prop_class.to_string() + if selected { " selected" } else { "" }
54 | }
55 |
56 | #[allow(unused_variables)]
57 | /// Get the classes for the elements inside of the cells of rows that are currently
58 | /// being loaded.
59 | /// The `prop_class` parameter contains the classes specified in the
60 | /// `loading_cell_class` prop of the [`TableContent`] component.
61 | fn loading_cell(&self, row_index: usize, col_index: usize, prop_class: &str) -> String {
62 | prop_class.to_string()
63 | }
64 |
65 | #[allow(unused_variables)]
66 | /// Get the classes for the elements inside of the cells of rows that are currently
67 | /// being loaded. Usually this will be some loading indicator like a sceleton bar.
68 | /// The `prop_class` parameter contains the classes specified in the
69 | /// `loading_cell_inner_class` prop of the [`TableContent`] component.
70 | fn loading_cell_inner(&self, row_index: usize, col_index: usize, prop_class: &str) -> String {
71 | prop_class.to_string()
72 | }
73 |
74 | /// Get the classes for the body cells.
75 | /// The `macro_class` parameter contains the classes specified in the `class` macro attribute of the field.
76 | fn cell(&self, macro_class: &str) -> String {
77 | macro_class.to_string()
78 | }
79 | }
80 |
81 | #[derive(Copy, Clone)]
82 | pub struct DummyTableClassesProvider;
83 |
84 | impl TableClassesProvider for DummyTableClassesProvider {
85 | fn new() -> Self {
86 | Self
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/examples/generic/src/main.rs:
--------------------------------------------------------------------------------
1 | //! Generic showcase example.
2 |
3 | use ::chrono::NaiveDate;
4 | use ::uuid::Uuid;
5 | use leptos::prelude::*;
6 | use leptos_struct_table::*;
7 |
8 | /// This generates the component BookTable
9 | #[derive(TableRow, Clone)]
10 | #[table(impl_vec_data_provider)]
11 | pub struct Book
12 | where
13 | // necessary trait bounds. `IntoView` is only necessary because we require it in
14 | // our custom renderer below, otherwise you could remove it here.
15 | // If you also make the table sortable then you might have to add `PartialOrd` as well.
16 | T: IntoView + Clone + Send + Sync + 'static,
17 | {
18 | /// Id of the entry.
19 | pub id: Uuid,
20 | /// Title of the book.
21 | pub title: String,
22 | /// Author of the book.
23 | pub author: String,
24 | /// Date when book has been published.
25 | pub publish_date: Option,
26 | /// Description of the book. Optional.
27 | #[table(none_value = "-")]
28 | pub description: Option,
29 |
30 | /// Generic field. You have to specify a custom renderer for a generic field.
31 | ///
32 | /// In case you need serde you also have to add
33 | /// ```
34 | /// #[serde(bound(deserialize = "T: DeserializeOwned"))]
35 | /// ```
36 | #[table(renderer = "CustomDataRenderer")]
37 | pub custom_data: T,
38 | }
39 |
40 | #[component]
41 | #[allow(unused_variables)]
42 | pub fn CustomDataRenderer(
43 | class: String,
44 | #[prop(into)] value: Signal,
45 | row: RwSignal>,
46 | index: usize,
47 | ) -> impl IntoView
48 | where
49 | T: IntoView + Clone + Send + Sync + 'static,
50 | {
51 | view! {
52 |
{value}
53 | }
54 | }
55 |
56 | fn main() {
57 | _ = console_log::init_with_level(log::Level::Debug);
58 | console_error_panic_hook::set_once();
59 |
60 | mount_to_body(|| {
61 | let rows = vec![
62 | Book {
63 | id: Uuid::new_v4(),
64 | title: "The Great Gatsby".to_string(),
65 | author: "F. Scott Fitzgerald".to_string(),
66 | publish_date: Some(NaiveDate::from_ymd_opt(1925, 4, 10).unwrap()),
67 | description: Some(
68 | "A story of wealth, love, and the American Dream in the 1920s.".to_string(),
69 | ),
70 | custom_data: "custom data is a string here".to_string(),
71 | },
72 | Book {
73 | id: Uuid::new_v4(),
74 | title: "The Grapes of Wrath".to_string(),
75 | author: "John Steinbeck".to_string(),
76 | publish_date: Some(NaiveDate::from_ymd_opt(1939, 4, 14).unwrap()),
77 | description: None,
78 | custom_data: "custom data is a string here".to_string(),
79 | },
80 | Book {
81 | id: Uuid::new_v4(),
82 | title: "Nineteen Eighty-Four".to_string(),
83 | author: "George Orwell".to_string(),
84 | publish_date: Some(NaiveDate::from_ymd_opt(1949, 6, 8).unwrap()),
85 | description: None,
86 | custom_data: "custom data is a string here".to_string(),
87 | },
88 | Book {
89 | id: Uuid::new_v4(),
90 | title: "Ulysses".to_string(),
91 | author: "James Joyce".to_string(),
92 | publish_date: Some(NaiveDate::from_ymd_opt(1922, 2, 2).unwrap()),
93 | description: None,
94 | custom_data: "still a string".to_string(),
95 | },
96 | ];
97 |
98 | view! {
99 |
100 |
101 |
102 | }
103 | })
104 | }
105 |
--------------------------------------------------------------------------------
/examples/serverfn_sqlx/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "serverfn_sqlx"
3 | version = "0.1.0"
4 | edition = "2021"
5 |
6 | [lib]
7 | crate-type = ["cdylib", "rlib"]
8 |
9 | [dependencies]
10 | axum = { version = "0.8", optional = true }
11 | console_error_panic_hook = "0.1"
12 | http = "1"
13 | leptos = { version = "0.8" }
14 | leptos-struct-table = { path = "../.." }
15 | leptos-use = { version = "0.16" }
16 | leptos_axum = { version = "0.8", optional = true }
17 | leptos_meta = { version = "0.8" }
18 | leptos_router = { version = "0.8" }
19 | serde = { version = "1.0.197", features = ["derive"] }
20 | sqlx = { version = "0.8", optional = true, features = [
21 | "sqlite",
22 | "runtime-tokio-rustls",
23 | ] }
24 | tokio = { version = "1", features = ["rt-multi-thread"], optional = true }
25 | tower = { version = "0.4", optional = true }
26 | tower-http = { version = "0.5", features = ["fs"], optional = true }
27 | tracing = { version = "0.1", optional = true }
28 | wasm-bindgen = "0.2.99"
29 |
30 | [features]
31 | hydrate = ["leptos/hydrate"]
32 | ssr = [
33 | "dep:axum",
34 | "dep:tokio",
35 | "dep:tower",
36 | "dep:tower-http",
37 | "dep:leptos_axum",
38 | "dep:sqlx",
39 | "leptos/ssr",
40 | "leptos_meta/ssr",
41 | "leptos_router/ssr",
42 | "leptos-use/ssr",
43 | "dep:tracing",
44 | ]
45 |
46 | # Defines a size-optimized profile for the WASM bundle in release mode
47 | [profile.wasm-release]
48 | inherits = "release"
49 | opt-level = 'z'
50 | lto = true
51 | codegen-units = 1
52 | panic = "abort"
53 |
54 | [package.metadata.leptos]
55 | # The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name
56 | output-name = "serverfn-sqlx"
57 |
58 | # The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
59 | site-root = "target/site"
60 |
61 | # The site-root relative folder where all compiled output (JS, WASM and CSS) is written
62 | # Defaults to pkg
63 | site-pkg-dir = "pkg"
64 |
65 | # [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to //app.css
66 | style-file = "style/output.css"
67 | # Assets source dir. All files found here will be copied and synchronized to site-root.
68 | # The assets-dir cannot have a sub directory with the same name/path as site-pkg-dir.
69 | #
70 | # Optional. Env: LEPTOS_ASSETS_DIR.
71 | assets-dir = "public"
72 |
73 | # The IP and port (ex: 127.0.0.1:3000) where the server serves the content. Use it in your server setup.
74 | site-addr = "127.0.0.1:3000"
75 |
76 | # The port to use for automatic reload monitoring
77 | reload-port = 3001
78 |
79 |
80 | # The browserlist query used for optimizing the CSS.
81 | browserquery = "defaults"
82 |
83 | # Set by cargo-leptos watch when building with that tool. Controls whether autoreload JS will be included in the head
84 | watch = false
85 |
86 | # The environment Leptos will run in, usually either "DEV" or "PROD"
87 | env = "DEV"
88 |
89 | # The features to use when compiling the bin target
90 | #
91 | # Optional. Can be over-ridden with the command line parameter --bin-features
92 | bin-features = ["ssr"]
93 |
94 | # If the --no-default-features flag should be used when compiling the bin target
95 | #
96 | # Optional. Defaults to false.
97 | bin-default-features = false
98 |
99 | # The features to use when compiling the lib target
100 | #
101 | # Optional. Can be over-ridden with the command line parameter --lib-features
102 | lib-features = ["hydrate"]
103 |
104 | # If the --no-default-features flag should be used when compiling the lib target
105 | #
106 | # Optional. Defaults to false.
107 | lib-default-features = false
108 |
109 | # The profile to use for the lib target when compiling for release
110 | #
111 | # Optional. Defaults to "release".
112 | lib-profile-release = "wasm-release"
113 |
114 | tailwind-input-file = "input.css"
115 |
--------------------------------------------------------------------------------
/examples/custom_row_renderer/src/main.rs:
--------------------------------------------------------------------------------
1 | #![deny(missing_docs)]
2 | //! Simple showcase example.
3 |
4 | use ::chrono::NaiveDate;
5 | use ::uuid::Uuid;
6 | use leptos::prelude::*;
7 | use leptos::web_sys;
8 | use leptos_struct_table::*;
9 |
10 | /// Custom row renderer that adds a link to the end of the row
11 | #[allow(unused_variables, non_snake_case)]
12 | pub fn CustomTableRowRenderer(
13 | // The class attribute for the row element. Generated by the classes provider.
14 | class: Signal,
15 | // The row to render.
16 | row: RwSignal,
17 | // The index of the row. Starts at 0 for the first body row.
18 | index: usize,
19 | // The selected state of the row. True, when the row is selected.
20 | selected: Signal,
21 | // Event handler callback when this row is selected
22 | on_select: EventHandler,
23 | ) -> impl IntoView {
24 |
25 | view! {
26 |
32 | }
33 | }
34 |
35 | /// This generates the component BookTable
36 | #[derive(TableRow, Clone)]
37 | #[table(sortable, impl_vec_data_provider)]
38 | pub struct Book {
39 | /// Id of the entry.
40 | pub id: Uuid,
41 | /// Title of the book.
42 | pub title: String,
43 | /// Author of the book.
44 | pub author: String,
45 | /// Date when book has been published.
46 | pub publish_date: Option,
47 | /// Description of the book. Optional.
48 | #[table(none_value = "-")]
49 | pub description: Option,
50 | /// Example on hidden member.
51 | #[table(skip)]
52 | pub hidden_field: String,
53 | /// Example of a headerless column
54 | #[table(skip_header)]
55 | pub rating: String,
56 | }
57 |
58 | fn main() {
59 | _ = console_log::init_with_level(log::Level::Debug);
60 | console_error_panic_hook::set_once();
61 |
62 | mount_to_body(|| {
63 | let rows = vec![
64 | Book {
65 | id: Uuid::new_v4(),
66 | title: "The Great Gatsby".to_string(),
67 | author: "F. Scott Fitzgerald".to_string(),
68 | publish_date: Some(NaiveDate::from_ymd_opt(1925, 4, 10).unwrap()),
69 | description: Some(
70 | "A story of wealth, love, and the American Dream in the 1920s.".to_string(),
71 | ),
72 | hidden_field: "hidden".to_string(),
73 | rating: "5/5".to_string(),
74 | },
75 | Book {
76 | id: Uuid::new_v4(),
77 | title: "The Grapes of Wrath".to_string(),
78 | author: "John Steinbeck".to_string(),
79 | publish_date: Some(NaiveDate::from_ymd_opt(1939, 4, 14).unwrap()),
80 | description: None,
81 | hidden_field: "not visible in the table".to_string(),
82 | rating: "4/5".to_string(),
83 | },
84 | Book {
85 | id: Uuid::new_v4(),
86 | title: "Nineteen Eighty-Four".to_string(),
87 | author: "George Orwell".to_string(),
88 | publish_date: Some(NaiveDate::from_ymd_opt(1949, 6, 8).unwrap()),
89 | description: None,
90 | hidden_field: "hidden".to_string(),
91 | rating: "19/84".to_string(),
92 | },
93 | Book {
94 | id: Uuid::new_v4(),
95 | title: "Ulysses".to_string(),
96 | author: "James Joyce".to_string(),
97 | publish_date: Some(NaiveDate::from_ymd_opt(1922, 2, 2).unwrap()),
98 | description: None,
99 | hidden_field: "hidden".to_string(),
100 | rating: "really long".to_string(),
101 | },
102 | ];
103 |
104 | view! {
105 |
106 |
111 |
112 | }
113 | })
114 | }
115 |
--------------------------------------------------------------------------------
/src/loaded_rows.rs:
--------------------------------------------------------------------------------
1 | use leptos::prelude::*;
2 | use std::ops::{Index, Range};
3 |
4 | pub enum RowState {
5 | /// The row is not yet loaded and a placeholder is displayed if the row is visible in the viewport.
6 | Placeholder,
7 | /// The row is loading and a placeholder is displayed if the row is visible in the viewport.
8 | Loading,
9 | /// The row has been loaded.
10 | Loaded(RwSignal),
11 | /// The row failed to load. This error is shown in the row if it's visible in the viewport.
12 | Error(String),
13 | }
14 |
15 | impl Clone for RowState {
16 | fn clone(&self) -> Self {
17 | match self {
18 | RowState::Placeholder => RowState::Placeholder,
19 | RowState::Loading => RowState::Loading,
20 | RowState::Loaded(signal) => RowState::Loaded(*signal),
21 | RowState::Error(error) => RowState::Error(error.clone()),
22 | }
23 | }
24 | }
25 |
26 | impl std::fmt::Debug for RowState {
27 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
28 | match self {
29 | RowState::Placeholder => write!(f, "Placeholder"),
30 | RowState::Loading => write!(f, "Loading"),
31 | RowState::Loaded(_) => write!(f, "Loaded"),
32 | RowState::Error(e) => write!(f, "Error({})", e),
33 | }
34 | }
35 | }
36 |
37 | /// This is basically a cache for rows and used by [`TableContent`] internally to track
38 | /// which rows are already loaded, which are still loading and which are missing.
39 | pub struct LoadedRows {
40 | rows: Vec>,
41 | }
42 |
43 | impl LoadedRows {
44 | pub fn new() -> Self {
45 | Self { rows: vec![] }
46 | }
47 |
48 | #[inline]
49 | pub fn len(&self) -> usize {
50 | self.rows.len()
51 | }
52 |
53 | #[inline]
54 | pub fn resize(&mut self, len: usize) {
55 | self.rows.resize(len, RowState::Placeholder);
56 | }
57 |
58 | pub fn write_loading(&mut self, range: Range) {
59 | if range.end > self.rows.len() {
60 | self.rows.resize(range.end, RowState::Placeholder);
61 | }
62 |
63 | for row in &mut self.rows[range] {
64 | *row = RowState::Loading;
65 | }
66 | }
67 |
68 | pub fn write_loaded(
69 | &mut self,
70 | loading_result: Result<(Vec, Range), String>,
71 | missing_range: Range,
72 | ) {
73 | match loading_result {
74 | Ok((rows, range)) => {
75 | if range.end > self.rows.len() {
76 | self.rows.resize(range.end, RowState::Placeholder);
77 | }
78 |
79 | for (self_row, loaded_row) in self.rows[range].iter_mut().zip(rows) {
80 | *self_row = RowState::Loaded(RwSignal::new(loaded_row));
81 | }
82 | }
83 | Err(error) => {
84 | let range = missing_range.start..missing_range.end.min(self.rows.len());
85 | if range.start >= range.end {
86 | return;
87 | }
88 |
89 | for row in &mut self.rows[range] {
90 | *row = RowState::Error(error.clone());
91 | }
92 | }
93 | }
94 | }
95 |
96 | #[inline]
97 | pub fn missing_range(&self, range: Range) -> Option> {
98 | let do_load_predicate = |row| matches!(row, &RowState::Placeholder);
99 |
100 | let slice = &self.rows[range.clone()];
101 |
102 | let start = slice.iter().position(do_load_predicate)?;
103 | let end = slice.iter().rposition(do_load_predicate)?;
104 |
105 | let start = start + range.start;
106 | let end = end + range.start + 1;
107 |
108 | Some(start..end)
109 | }
110 |
111 | #[inline]
112 | pub fn clear(&mut self) {
113 | self.rows.fill(RowState::Placeholder);
114 | }
115 | }
116 |
117 | impl Index> for LoadedRows {
118 | type Output = [RowState];
119 |
120 | #[inline]
121 | fn index(&self, index: Range) -> &Self::Output {
122 | &self.rows[index]
123 | }
124 | }
125 |
126 | impl Index for LoadedRows {
127 | type Output = RowState;
128 |
129 | #[inline]
130 | fn index(&self, index: usize) -> &Self::Output {
131 | &self.rows[index]
132 | }
133 | }
134 |
--------------------------------------------------------------------------------
/src/time.rs:
--------------------------------------------------------------------------------
1 | //! Support for [::time] crate.
2 |
3 | use crate::*;
4 | use ::time::format_description;
5 | use ::time::{Date, OffsetDateTime, PrimitiveDateTime, Time};
6 | use leptos::prelude::*;
7 |
8 | #[derive(Clone, Default)]
9 | pub struct RenderTimeOptions {
10 | /// Specifies a format string see [the time book](https://time-rs.github.io/book/api/format-description.html).
11 | pub string: Option,
12 | }
13 |
14 | /// Implementation for [`Date`] to work with the [`TableRow`] derive and the [`DefaultTableCellRenderer`]
15 | /// ```
16 | /// # use leptos_struct_table::*;
17 | /// # use leptos::prelude::*;
18 | /// # use ::time::Date;
19 | /// #[derive(TableRow, Clone)]
20 | /// #[table]
21 | /// struct SomeStruct {
22 | /// #[table(format(string = "[year]-[month]-[day]"))]
23 | /// my_field: Date
24 | /// }
25 | /// ```
26 | impl CellValue for Date {
27 | type RenderOptions = RenderTimeOptions;
28 |
29 | fn render_value(self, options: Self::RenderOptions) -> impl IntoView {
30 | if let Some(value) = options.string.as_ref() {
31 | let format = format_description::parse(value)
32 | .expect("Unable to construct a format description given the format string");
33 | self.format(&format)
34 | .expect("Unable to format given the format description")
35 | } else {
36 | self.to_string()
37 | }
38 | }
39 | }
40 | /// Implementation for [`Time`] to work with the [`TableRow`] derive and the [`DefaultTableCellRenderer`]
41 | /// ```
42 | /// # use leptos_struct_table::*;
43 | /// # use leptos::prelude::*;
44 | /// # use ::time::Time;
45 | /// #[derive(TableRow, Clone)]
46 | /// #[table]
47 | /// struct SomeStruct {
48 | /// #[table(format(string = "[hour]:[minute]:[second]"))]
49 | /// my_field: Time
50 | /// }
51 | /// ```
52 | impl CellValue
` to produce valid HTML. This fixes SSR rendering issues.
172 |
173 | ### Other Changes
174 |
175 | - Added an example for how to use server functions and sqlx together with this crate.
176 |
177 | ## [0.8.3] - 2024-02-20
178 |
179 | ### Fix 🐛
180 |
181 | - When not limiting a scroll container this could lead to a runaway row loading. This is now limited to max 500 rows.
182 |
183 | ## [0.8.2] - 2024-02-18
184 |
185 | ### Feature 🚀
186 |
187 | - Added method `TableDataProvider::track` to easily specify reactive dependencies of data loading
188 |
189 | ## [0.8.1] - 2024-02-17
190 |
191 | ### Fix 🐛
192 |
193 | - Removed debug log
194 |
195 | ## [0.8.0] - 2024-02-17
196 |
197 | ### Feature 🚀
198 |
199 | - Added `loading_row_display_limit` prop to `TableContent` to make it possible to load smaller row counts nicely
200 |
201 | ### Breaking Changes 🛠️
202 |
203 | - Added `row_index` and `col_index` to `TableClassesProvider::loading_cell`
204 | - Added `col_index` to `TableClassesProvider::loading_cell_inner`
205 | - Changed the type of prop `loading_row_renderer` of the component `TableContent`
206 |
207 | ### Fix 🐛
208 |
209 | - Data loading for small data sets
210 |
211 | ## [0.7.1] - 2024-02-14
212 |
213 | ### Changes
214 |
215 | - Added generic error type to `TableDataProvider`
216 | - Fixed sorting for tables with skipped fields
217 |
218 | ## [0.7.0] - 2024-02-08
219 |
220 | ### Features 🚀
221 |
222 | - Virtualization — Only elements that are visible are rendered (with some extra for smooth scrolling).
223 | - Other display acceleration strategies like infinite scroll and pagination are implemented as well.
224 | - Caching — Only rows that are visible are requested from the data source and then cached.
225 | - Error handling — If an error occurs while loading data, it is displayed in a table row instead of the failed data.
226 | - Easy reloading — The data can be reloaded through the `ReloadController`.
227 |
228 | ### Breaking Changes 🛠️
229 |
230 | Everything? - sorry. This release is like half a rewrite with much less macro magic.
231 | Please check the docs and examples.
232 |
233 | ## [0.6.0] - 2023-11-02
234 |
235 | ### New Feature 🎉
236 |
237 | - Support for generic structs
238 |
239 | ### Fix 🐛
240 |
241 | - Fixed `#[table(skip_sort)]` on fields
242 |
243 | ## [0.5.0] - 2023-10-20
244 |
245 | ### Breaking Changes 🛠️
246 |
247 | - Added `on_change` events to support editable data (see new editable example)
248 |
249 | ### Fixes 🐛
250 |
251 | - Fixed selection with `key`s that are not `Copy`
252 |
253 | ### Other Changes
254 |
255 | - Modified REST example to include sorting
256 |
257 | ## [0.4.0] - 2023-10-02
258 |
259 | - Updated to leptos 0.5
260 |
261 | ## [0.3.0]
262 |
263 | - Updated to leptos 0.4
264 |
265 | ## [0.2.0]
266 |
267 | - Updated to leptos 0.3
268 | - Deactivated `default-features` of leptos
269 | - New class provider `BootstrapClassesPreset`
270 | - New example `bootstrap`
271 | - Added `thead` and `tbody` with customizable renderers
272 | - Added `getter` and `FieldGetter` with new example
273 |
--------------------------------------------------------------------------------
/LICENSE-APACHE:
--------------------------------------------------------------------------------
1 | Apache License
2 | Version 2.0, January 2004
3 | http://www.apache.org/licenses/
4 |
5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6 |
7 | 1. Definitions.
8 |
9 | "License" shall mean the terms and conditions for use, reproduction,
10 | and distribution as defined by Sections 1 through 9 of this document.
11 |
12 | "Licensor" shall mean the copyright owner or entity authorized by
13 | the copyright owner that is granting the License.
14 |
15 | "Legal Entity" shall mean the union of the acting entity and all
16 | other entities that control, are controlled by, or are under common
17 | control with that entity. For the purposes of this definition,
18 | "control" means (i) the power, direct or indirect, to cause the
19 | direction or management of such entity, whether by contract or
20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
21 | outstanding shares, or (iii) beneficial ownership of such entity.
22 |
23 | "You" (or "Your") shall mean an individual or Legal Entity
24 | exercising permissions granted by this License.
25 |
26 | "Source" form shall mean the preferred form for making modifications,
27 | including but not limited to software source code, documentation
28 | source, and configuration files.
29 |
30 | "Object" form shall mean any form resulting from mechanical
31 | transformation or translation of a Source form, including but
32 | not limited to compiled object code, generated documentation,
33 | and conversions to other media types.
34 |
35 | "Work" shall mean the work of authorship, whether in Source or
36 | Object form, made available under the License, as indicated by a
37 | copyright notice that is included in or attached to the work
38 | (an example is provided in the Appendix below).
39 |
40 | "Derivative Works" shall mean any work, whether in Source or Object
41 | form, that is based on (or derived from) the Work and for which the
42 | editorial revisions, annotations, elaborations, or other modifications
43 | represent, as a whole, an original work of authorship. For the purposes
44 | of this License, Derivative Works shall not include works that remain
45 | separable from, or merely link (or bind by name) to the interfaces of,
46 | the Work and Derivative Works thereof.
47 |
48 | "Contribution" shall mean any work of authorship, including
49 | the original version of the Work and any modifications or additions
50 | to that Work or Derivative Works thereof, that is intentionally
51 | submitted to Licensor for inclusion in the Work by the copyright owner
52 | or by an individual or Legal Entity authorized to submit on behalf of
53 | the copyright owner. For the purposes of this definition, "submitted"
54 | means any form of electronic, verbal, or written communication sent
55 | to the Licensor or its representatives, including but not limited to
56 | communication on electronic mailing lists, source code control systems,
57 | and issue tracking systems that are managed by, or on behalf of, the
58 | Licensor for the purpose of discussing and improving the Work, but
59 | excluding communication that is conspicuously marked or otherwise
60 | designated in writing by the copyright owner as "Not a Contribution."
61 |
62 | "Contributor" shall mean Licensor and any individual or Legal Entity
63 | on behalf of whom a Contribution has been received by Licensor and
64 | subsequently incorporated within the Work.
65 |
66 | 2. Grant of Copyright License. Subject to the terms and conditions of
67 | this License, each Contributor hereby grants to You a perpetual,
68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
69 | copyright license to reproduce, prepare Derivative Works of,
70 | publicly display, publicly perform, sublicense, and distribute the
71 | Work and such Derivative Works in Source or Object form.
72 |
73 | 3. Grant of Patent License. Subject to the terms and conditions of
74 | this License, each Contributor hereby grants to You a perpetual,
75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
76 | (except as stated in this section) patent license to make, have made,
77 | use, offer to sell, sell, import, and otherwise transfer the Work,
78 | where such license applies only to those patent claims licensable
79 | by such Contributor that are necessarily infringed by their
80 | Contribution(s) alone or by combination of their Contribution(s)
81 | with the Work to which such Contribution(s) was submitted. If You
82 | institute patent litigation against any entity (including a
83 | cross-claim or counterclaim in a lawsuit) alleging that the Work
84 | or a Contribution incorporated within the Work constitutes direct
85 | or contributory patent infringement, then any patent licenses
86 | granted to You under this License for that Work shall terminate
87 | as of the date such litigation is filed.
88 |
89 | 4. Redistribution. You may reproduce and distribute copies of the
90 | Work or Derivative Works thereof in any medium, with or without
91 | modifications, and in Source or Object form, provided that You
92 | meet the following conditions:
93 |
94 | (a) You must give any other recipients of the Work or
95 | Derivative Works a copy of this License; and
96 |
97 | (b) You must cause any modified files to carry prominent notices
98 | stating that You changed the files; and
99 |
100 | (c) You must retain, in the Source form of any Derivative Works
101 | that You distribute, all copyright, patent, trademark, and
102 | attribution notices from the Source form of the Work,
103 | excluding those notices that do not pertain to any part of
104 | the Derivative Works; and
105 |
106 | (d) If the Work includes a "NOTICE" text file as part of its
107 | distribution, then any Derivative Works that You distribute must
108 | include a readable copy of the attribution notices contained
109 | within such NOTICE file, excluding those notices that do not
110 | pertain to any part of the Derivative Works, in at least one
111 | of the following places: within a NOTICE text file distributed
112 | as part of the Derivative Works; within the Source form or
113 | documentation, if provided along with the Derivative Works; or,
114 | within a display generated by the Derivative Works, if and
115 | wherever such third-party notices normally appear. The contents
116 | of the NOTICE file are for informational purposes only and
117 | do not modify the License. You may add Your own attribution
118 | notices within Derivative Works that You distribute, alongside
119 | or as an addendum to the NOTICE text from the Work, provided
120 | that such additional attribution notices cannot be construed
121 | as modifying the License.
122 |
123 | You may add Your own copyright statement to Your modifications and
124 | may provide additional or different license terms and conditions
125 | for use, reproduction, or distribution of Your modifications, or
126 | for any such Derivative Works as a whole, provided Your use,
127 | reproduction, and distribution of the Work otherwise complies with
128 | the conditions stated in this License.
129 |
130 | 5. Submission of Contributions. Unless You explicitly state otherwise,
131 | any Contribution intentionally submitted for inclusion in the Work
132 | by You to the Licensor shall be under the terms and conditions of
133 | this License, without any additional terms or conditions.
134 | Notwithstanding the above, nothing herein shall supersede or modify
135 | the terms of any separate license agreement you may have executed
136 | with Licensor regarding such Contributions.
137 |
138 | 6. Trademarks. This License does not grant permission to use the trade
139 | names, trademarks, service marks, or product names of the Licensor,
140 | except as required for reasonable and customary use in describing the
141 | origin of the Work and reproducing the content of the NOTICE file.
142 |
143 | 7. Disclaimer of Warranty. Unless required by applicable law or
144 | agreed to in writing, Licensor provides the Work (and each
145 | Contributor provides its Contributions) on an "AS IS" BASIS,
146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 | implied, including, without limitation, any warranties or conditions
148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 | PARTICULAR PURPOSE. You are solely responsible for determining the
150 | appropriateness of using or redistributing the Work and assume any
151 | risks associated with Your exercise of permissions under this License.
152 |
153 | 8. Limitation of Liability. In no event and under no legal theory,
154 | whether in tort (including negligence), contract, or otherwise,
155 | unless required by applicable law (such as deliberate and grossly
156 | negligent acts) or agreed to in writing, shall any Contributor be
157 | liable to You for damages, including any direct, indirect, special,
158 | incidental, or consequential damages of any character arising as a
159 | result of this License or out of the use or inability to use the
160 | Work (including but not limited to damages for loss of goodwill,
161 | work stoppage, computer failure or malfunction, or any and all
162 | other commercial damages or losses), even if such Contributor
163 | has been advised of the possibility of such damages.
164 |
165 | 9. Accepting Warranty or Additional Liability. While redistributing
166 | the Work or Derivative Works thereof, You may choose to offer,
167 | and charge a fee for, acceptance of support, warranty, indemnity,
168 | or other liability obligations and/or rights consistent with this
169 | License. However, in accepting such obligations, You may act only
170 | on Your own behalf and on Your sole responsibility, not on behalf
171 | of any other Contributor, and only if You agree to indemnify,
172 | defend, and hold each Contributor harmless for any liability
173 | incurred by, or claims asserted against, such Contributor by reason
174 | of your accepting any such warranty or additional liability.
175 |
176 | END OF TERMS AND CONDITIONS
177 |
--------------------------------------------------------------------------------