DioxusLabs · nicoburns · Nov 21, 2023 · Apr 25, 2023 · Apr 25, 2023 · Apr 25, 2023
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -56,6 +56,15 @@ jobs:
       - run: cargo build --features serde
       - run: cargo test --features serde
 
+  test-features-default-except-content-size:
+    name: "Test Suite [Features: Default except content_size]"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo build --no-default-features --features std,taffy_tree,grid,flexbox,block_layout
+      - run: cargo test --no-default-features --features std,taffy_tree,grid,flexbox,block_layout
+
   test-features-no-grid-nor-flexbox:
     name: "Test Suite [Features: std (no grid or flexbox)]"
     runs-on: ubuntu-latest

diff --git a/Cargo.toml b/Cargo.toml
@@ -21,17 +21,39 @@ serde = { version = "1.0", optional = true, features = ["serde_derive"] }
 slotmap = { version = "1.0.6", optional = true }
 grid = { version = "0.11.0", default-features = false, optional = true }
 
+### FEATURES #################################################################
+
 [features]
-default = ["std", "flexbox", "grid", "block_layout", "taffy_tree"]
+default = ["std", "taffy_tree", "flexbox", "grid", "block_layout", "content_size"]
+
+### Algorithms 
+
+# Enables the Block layout algorithm
 block_layout = []
+# Enables the Flexbox layout algorithm
 flexbox = []
+# Enables the CSS Grid layout algorithm
 grid = ["alloc", "dep:grid"]
-alloc = []
-std = ["num-traits/std", "grid?/std"]
+# Causes all algorithms to compute and output a content size for each node
+content_size = []
+
+### Taffy Tree
+
+# Enable the built-in Taffy node tree
+taffy_tree = ["dep:slotmap"]
+
+### Other
+
+# Add serde derives to Style structs
 serde = ["dep:serde"]
+# Allow Taffy to depend on the standard library
+std = ["num-traits/std", "grid?/std"]
+# Allow Taffy to depend on the alloc library
+alloc = []
+# Internal featyre for debugging
 debug = ["std"]
+# Internal feature for profiling
 profile = ["std"]
-taffy_tree = ["dep:slotmap"]
 
 [dev-dependencies]
 serde_json = "1.0.93"

diff --git a/benches/Cargo.toml b/benches/Cargo.toml
@@ -26,6 +26,7 @@ slotmap = { version = "1.0.6", optional = true }
 yoga = ["dep:yoga", "dep:slotmap", "dep:ordered-float"]
 yoga-super-deep = ["yoga"]
 taffy03 = ["dep:taffy_03"]
+content_size = ["taffy/content_size"]
 small = []
 large = []
 

diff --git a/scripts/gentest/src/main.rs b/scripts/gentest/src/main.rs
@@ -234,11 +234,15 @@ fn generate_assertions(ident: &str, node: &Value, use_rounding: bool) -> TokenSt
     let layout = if use_rounding { &node["smartRoundedLayout"] } else { &node["unroundedLayout"] };
 
     let read_f32 = |s: &str| layout[s].as_f64().unwrap() as f32;
+    let read_naive_f32 = |s: &str| node["naivelyRoundedLayout"][s].as_f64().unwrap() as f32;
     let width = read_f32("width");
     let height = read_f32("height");
     let x = read_f32("x");
     let y = read_f32("y");
 
+    let scroll_width = (read_f32("scrollWidth") - read_naive_f32("clientWidth")).max(0.0);
+    let scroll_height = (read_f32("scrollHeight") - read_naive_f32("clientHeight")).max(0.0);
+
     let children = {
         let mut c = Vec::new();
         if let Value::Array(ref value) = node["children"] {
@@ -253,21 +257,31 @@ fn generate_assertions(ident: &str, node: &Value, use_rounding: bool) -> TokenSt
 
     if use_rounding {
         quote!(
-            let Layout { size, location, .. } = taffy.layout(#ident).unwrap();
+            #[cfg_attr(not(feature = "content_size"), allow(unused_variables))]
+            let layout @ Layout { size, location, .. } = taffy.layout(#ident).unwrap();
             assert_eq!(size.width, #width, "width of node {:?}. Expected {}. Actual {}", #ident,  #width, size.width);
             assert_eq!(size.height, #height, "height of node {:?}. Expected {}. Actual {}", #ident,  #height, size.height);
             assert_eq!(location.x, #x, "x of node {:?}. Expected {}. Actual {}", #ident,  #x, location.x);
             assert_eq!(location.y, #y, "y of node {:?}. Expected {}. Actual {}", #ident,  #y, location.y);
+            #[cfg(feature = "content_size")]
+            assert_eq!(layout.scroll_width(), #scroll_width, "scroll_width of node {:?}. Expected {}. Actual {}", #ident, #scroll_width, layout.scroll_width());
+            #[cfg(feature = "content_size")]
+            assert_eq!(layout.scroll_height(), #scroll_height, "scroll_height of node {:?}. Expected {}. Actual {}", #ident, #scroll_height, layout.scroll_height());
 
             #children
         )
     } else {
         quote!(
-            let Layout { size, location, .. } = taffy.layout(#ident).unwrap();
-            assert!(size.width - #width < 0.1, "width of node {:?}. Expected {}. Actual {}", #ident,  #width, size.width);
-            assert!(size.height - #height < 0.1, "height of node {:?}. Expected {}. Actual {}", #ident,  #height, size.height);
-            assert!(location.x - #x < 0.1, "x of node {:?}. Expected {}. Actual {}", #ident,  #x, location.x);
-            assert!(location.y - #y < 0.1, "y of node {:?}. Expected {}. Actual {}", #ident,  #y, location.y);
+            #[cfg_attr(not(feature = "content_size"), allow(unused_variables))]
+            let layout @ Layout { size, location, .. } = taffy.layout(#ident).unwrap();
+            assert!((size.width - #width).abs() < 0.1, "width of node {:?}. Expected {}. Actual {}", #ident, #width, size.width);
+            assert!((size.height - #height).abs() < 0.1, "height of node {:?}. Expected {}. Actual {}", #ident, #height, size.height);
+            assert!((location.x - #x).abs() < 0.1, "x of node {:?}. Expected {}. Actual {}", #ident, #x, location.x);
+            assert!((location.y - #y).abs() < 0.1, "y of node {:?}. Expected {}. Actual {}", #ident, #y, location.y);
+            #[cfg(feature = "content_size")]
+            assert!((layout.scroll_width() - #scroll_width).abs() < 0.1, "scroll_width of node {:?}. Expected {}. Actual {}", #ident, #scroll_width, layout.scroll_width());
+            #[cfg(feature = "content_size")]
+            assert!((layout.scroll_height() - #scroll_height).abs() < 0.1, "scroll_height of node {:?}. Expected {}. Actual {}", #ident, #scroll_height, layout.scroll_height());
 
             #children
         )
@@ -867,6 +881,8 @@ fn generate_scalar_definition(track_definition: &serde_json::Map<String, Value>)
 }
 
 fn generate_node_context(text_content: &str, writing_mode: Option<&str>, aspect_ratio: Option<f32>) -> TokenStream {
+    let trimmed_text_content = text_content.trim();
+
     let writing_mode_token = match writing_mode {
         Some("vertical-rl" | "vertical-lr") => quote!(crate::WritingMode::Vertical),
         _ => quote!(crate::WritingMode::Horizontal),
@@ -879,7 +895,7 @@ fn generate_node_context(text_content: &str, writing_mode: Option<&str>, aspect_
 
     quote!(
         crate::TextMeasure {
-            text_content: #text_content,
+            text_content: #trimmed_text_content,
             writing_mode: #writing_mode_token,
             _aspect_ratio: #aspect_ratio_token,
         }

diff --git a/scripts/gentest/test_helper.js b/scripts/gentest/test_helper.js
@@ -284,6 +284,10 @@ function describeElement(e) {
       height: boundingRect.height,
       x: boundingRect.x - parentBoundingRect.x,
       y: boundingRect.y - parentBoundingRect.y,
+      scrollWidth: e.scrollWidth,
+      scrollHeight: e.scrollHeight,
+      clientWidth: e.clientWidth,
+      clientHeight: e.clientHeight,
     },
 
     // The naively rounded layout of the node. This is equivalent to calling Math.round() on
@@ -293,6 +297,10 @@ function describeElement(e) {
       height: e.offsetHeight,
       x: e.offsetLeft + e.parentNode.clientLeft,
       y: e.offsetTop + e.parentNode.clientTop,
+      scrollWidth: e.scrollWidth,
+      scrollHeight: e.scrollHeight,
+      clientWidth: e.clientWidth,
+      clientHeight: e.clientHeight,
     },
 
     // The naive rounding can result in 1px gaps in the layout, so Taffy uses a smarter algorithm to avoid this.
@@ -303,6 +311,10 @@ function describeElement(e) {
       height: Math.round(boundingRect.bottom) - Math.round(boundingRect.top),
       x: Math.round(boundingRect.x - parentBoundingRect.x),
       y: Math.round(boundingRect.y - parentBoundingRect.y),
+      scrollWidth: e.scrollWidth,
+      scrollHeight: e.scrollHeight,
+      clientWidth: e.clientWidth,
+      clientHeight: e.clientHeight,
     },
 
     // Whether the test should enable rounding