webwidgets 1.1.0__tar.gz → 1.1.1__tar.gz

{webwidgets-1.1.0 → webwidgets-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webwidgets
-Version: 1.1.0
+Version: 1.1.1
 Summary: A Python package for designing web UIs.
 Project-URL: Source code, https://github.com/mlaasri/WebWidgets
 Author: mlaasri

{webwidgets-1.1.0 → webwidgets-1.1.1}/tests/compilation/test_css_sections.py

@@ -32,6 +32,7 @@ class TestPreamble:
             "    box-sizing: border-box;",
             "    margin: 0;",
             "    padding: 0;",
+            "    overflow: hidden;",
             "}"
         ])
         assert preamble.to_css() == expected_css

webwidgets-1.1.1/tests/utility/sizes/test_size.py

@@ -0,0 +1,59 @@
+# =======================================================================
+#
+#  This file is part of WebWidgets, a Python package for designing web
+#  UIs.
+#
+#  You should have received a copy of the MIT License along with
+#  WebWidgets. If not, see <https://opensource.org/license/mit>.
+#
+#  Copyright(C) 2025, mlaasri
+#
+# =======================================================================
+
+import pytest
+from webwidgets.utility.sizes.size import Size, AbsoluteSize, RelativeSize, \
+    with_unit
+import webwidgets as ww
+
+
+class TestSize:
+    @pytest.mark.parametrize("value", [0, 10, 10.0, 12.33])
+    def test_size(self, value):
+        size = Size(value)
+        assert size.value == value
+        assert size.unit == "size"
+        assert size.to_css() == f"{value}size"
+
+    @pytest.mark.parametrize("attr_to_test",
+                             [AbsoluteSize, RelativeSize, Size,
+                              with_unit])
+    def test_size_helpers_not_at_top_level(self, attr_to_test):
+        """Tests the visibility of helper classes and functions."""
+        # Making sure the class or function exists in the proper size module
+        assert hasattr(ww.utility.size, attr_to_test.__name__)
+
+        # Making sure it is not visible at the top level
+        assert not hasattr(ww, attr_to_test.__name__)
+
+    def test_absolute_size_not_importable_at_top_level(self):
+        with pytest.raises(AttributeError, match="AbsoluteSize"):
+            ww.AbsoluteSize(5)
+
+    def test_relative_size_not_importable_at_top_level(self):
+        with pytest.raises(AttributeError, match="RelativeSize"):
+            ww.RelativeSize(5)
+
+    def test_size_not_importable_at_top_level(self):
+        with pytest.raises(AttributeError, match="Size"):
+            ww.Size(5)
+
+    def test_with_unit_not_importable_at_top_level(self):
+        with pytest.raises(AttributeError, match="with_unit"):
+            ww.with_unit("10px")
+
+    @pytest.mark.parametrize("unit", ["m", "cm", "%"])
+    def test_with_unit(self, unit):
+        @with_unit(unit)
+        class CustomUnit(Size):
+            pass
+        assert CustomUnit(3).to_css() == f"3{unit}"

webwidgets-1.1.1/tests/utility/sizes/test_sizes.py

@@ -0,0 +1,33 @@
+# =======================================================================
+#
+#  This file is part of WebWidgets, a Python package for designing web
+#  UIs.
+#
+#  You should have received a copy of the MIT License along with
+#  WebWidgets. If not, see <https://opensource.org/license/mit>.
+#
+#  Copyright(C) 2025, mlaasri
+#
+# =======================================================================
+
+import pytest
+from webwidgets.utility.sizes.size import AbsoluteSize, RelativeSize
+import webwidgets as ww
+
+
+class TestSizes:
+    @pytest.mark.parametrize("value", [0, 10, 10.0, 82.33])
+    def test_percent(self, value):
+        size = ww.Percent(value)
+        assert isinstance(size, RelativeSize)
+        assert size.value == value
+        assert size.unit == "%"
+        assert size.to_css() == f"{value}%"
+
+    @pytest.mark.parametrize("value", [0, 10, 10.0, 12.33])
+    def test_px(self, value):
+        size = ww.Px(value)
+        assert isinstance(size, AbsoluteSize)
+        assert size.value == value
+        assert size.unit == "px"
+        assert size.to_css() == f"{value}px"

{webwidgets-1.1.0 → webwidgets-1.1.1}/tests/utility/test_validation.py

@@ -16,10 +16,11 @@ import re
 from webwidgets.compilation.css import apply_css, compile_css
 from webwidgets.compilation.html import HTMLNode
 from webwidgets.utility.validation import validate_css_comment, \
-    validate_css_identifier, validate_css_selector, validate_html_class
+    validate_css_identifier, validate_css_selector, validate_css_value, \
+    validate_html_class
 
 
-class TestValidate:
+class TestValidateCSS:
     @pytest.fixture
     def valid_css_identifiers(self):
         return [
@@ -160,6 +161,32 @@ class TestValidate:
         with pytest.raises(ValueError, match=r"Invalid character\(s\).* !"):
             validate_css_selector(".h!")
 
+    def test_valid_css_values(self):
+        """Tests that valid CSS property values are accepted"""
+        validate_css_value("abcdefghijklmnopqrstuvwxyz")
+        validate_css_value("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+        validate_css_value("0123456789")
+        validate_css_value("9876543210px")
+        validate_css_value("blue 0 0 5-5 30px")
+        validate_css_value("4 orange 56")
+        validate_css_value("4 oRAnGe  56")
+        validate_css_value("border-box")
+        validate_css_value("5 #ff0Az3 space-between auto 10%m")
+
+    @pytest.mark.parametrize("char1", "!@$^&*()<>?/|\\}{[\":;\']")
+    @pytest.mark.parametrize("char2", "}{")
+    @pytest.mark.parametrize("use_char2", (False, True))
+    def test_invalid_css_value_with_invalid_character(self, char1, char2,
+                                                      use_char2):
+        """Tests that an invalid CSS value (containing one or two invalid
+        characters) raises an exception"""
+        chars = ', '.join([char1, char2] if use_char2 else [char1])
+        with pytest.raises(ValueError,
+                           match=fr"Invalid character\(s\).*{re.escape(chars)}"):
+            validate_css_value(f"red-{char1} 0{char2 if use_char2 else ''} px")
+
+
+class TestValidateHTML:
     def test_valid_html_classes(self):
         """Test that valid HTML class attributes are accepted"""
         validate_html_class("")

webwidgets-1.1.1/tests/widgets/containers/test_box.py

@@ -0,0 +1,465 @@
+# =======================================================================
+#
+#  This file is part of WebWidgets, a Python package for designing web
+#  UIs.
+#
+#  You should have received a copy of the MIT License along with
+#  WebWidgets. If not, see <https://opensource.org/license/mit>.
+#
+#  Copyright(C) 2025, mlaasri
+#
+# =======================================================================
+
+import numpy as np
+import pytest
+from typing import Tuple
+import webwidgets as ww
+from webwidgets.compilation.html import Div
+from webwidgets.widgets.containers.box import BoxItemProperties
+
+
+class TestBox:
+
+    # A simple color widget
+    class Color(ww.Widget):
+        def __init__(self,
+                     color: Tuple[int, int, int],
+                     height: str = "100%",
+                     width: str = "100%"):
+            super().__init__()
+            self.color = color
+            self.height = height
+            self.width = width
+
+        def build(self):
+            hex_color = "#%02x%02x%02x" % self.color
+            return Div(style={"background-color": hex_color,
+                              "height": self.height,
+                              "width": self.width})
+
+    # A Box that fills the entire viewport
+    class FullViewportBox(ww.Box):
+        def build(self, *args, **kwargs):
+            node = super().build(*args, **kwargs)
+            node.style["width"] = "100vw"
+            node.style["height"] = "100vh"
+            return node
+
+    # A Box that expands to 100% of its available space
+    class FullyExpandedBox(ww.Box):
+        def build(self, *args, **kwargs):
+            node = super().build(*args, **kwargs)
+            node.style["width"] = "100%"
+            node.style["height"] = "100%"
+            return node
+
+    @pytest.mark.parametrize("colors", [
+        [(255, 0, 0)],
+        [(255, 0, 0), (0, 255, 0)],
+        [(255, 0, 0), (0, 255, 0), (0, 0, 255)]
+    ])
+    def test_horizontal_box(self, colors, render_page, web_drivers):
+        """Tests the even distribution of multiple colored widgets by a Box."""
+        # Creating a page with one box containing widgets with the given colors
+        box = TestBox.FullViewportBox(direction=ww.Direction.HORIZONTAL)
+        for color in colors:
+            box.add(TestBox.Color(color=color))
+        page = ww.Page([box])
+
+        for web_driver in web_drivers:
+
+            # Rendering the page with the box
+            array = render_page(page, web_driver)
+
+            # Computing the regions where to search for each color. If the
+            # colors cannot spread evenly (which happens when the image size is
+            # not divisible by the number of colors), we exclude all edges
+            # where one color stops and another starts.
+            all_indices = np.arange(array.shape[1])
+            edges = np.linspace(0, array.shape[1], len(colors) + 1)[1:-1]
+            edges = np.floor(edges).astype(np.int32)
+            regions = np.split(all_indices, edges)
+            if array.shape[1] % len(colors) != 0:
+                regions = [r[~np.isin(r, edges)] for r in regions]
+
+            assert len(regions) == len(colors)  # One region per color
+            for color, region in zip(colors, regions):
+                assert np.all(array[:, region, 0] == color[0])
+                assert np.all(array[:, region, 1] == color[1])
+                assert np.all(array[:, region, 2] == color[2])
+
+    @pytest.mark.parametrize("colors", [
+        [(255, 0, 0)],
+        [(255, 0, 0), (0, 255, 0)],
+        [(255, 0, 0), (0, 255, 0), (0, 0, 255)]
+    ])
+    def test_vertical_box(self, colors, render_page, web_drivers):
+        """Tests the even distribution of multiple colored widgets by a Box."""
+        # Creating a page with one box containing widgets with the given colors
+        box = TestBox.FullViewportBox(direction=ww.Direction.VERTICAL)
+        for color in colors:
+            box.add(TestBox.Color(color=color))
+        page = ww.Page([box])
+
+        for web_driver in web_drivers:
+
+            # Rendering the page with the box
+            array = render_page(page, web_driver)
+
+            # Computing the regions where to search for each color. If the
+            # colors cannot spread evenly (which happens when the image size is
+            # not divisible by the number of colors), we exclude all edges
+            # where one color stops and another starts.
+            all_indices = np.arange(array.shape[0])
+            edges = np.linspace(0, array.shape[0], len(colors) + 1)[1:-1]
+            edges = np.floor(edges).astype(np.int32)
+            regions = np.split(all_indices, edges)
+            if array.shape[0] % len(colors) != 0:
+                regions = [r[~np.isin(r, edges)] for r in regions]
+
+            assert len(regions) == len(colors)  # One region per color
+            for color, region in zip(colors, regions):
+                assert np.all(array[region, :, 0] == color[0])
+                assert np.all(array[region, :, 1] == color[1])
+                assert np.all(array[region, :, 2] == color[2])
+
+    def test_nested_boxes(self, render_page, web_drivers):
+        """Tests that two nested boxes with orthogonal directions render
+        correctly.
+        """
+        top_box = TestBox.FullyExpandedBox(direction=ww.Direction.HORIZONTAL)
+        top_box.add(TestBox.Color(color=(255, 0, 0)))
+        top_box.add(TestBox.Color(color=(0, 255, 0)))
+        out_box = TestBox.FullViewportBox(direction=ww.Direction.VERTICAL)
+        out_box.add(top_box)
+        out_box.add(TestBox.Color(color=(0, 0, 255)))
+        page = ww.Page([out_box])
+
+        for web_driver in web_drivers:
+            a = render_page(page, web_driver)
+            for i, c in enumerate((255, 0, 0)):
+                assert np.all(a[:a.shape[0] // 2, :a.shape[1] // 2, i] == c)
+            edge_col = a.shape[1] // 2 + (0 if a.shape[1] % 2 == 0 else 1)
+            for i, c in enumerate((0, 255, 0)):
+                assert np.all(a[:a.shape[0] // 2, edge_col:, i] == c)
+            edge_row = a.shape[0] // 2 + (0 if a.shape[0] % 2 == 0 else 1)
+            for i, c in enumerate((0, 0, 255)):
+                assert np.all(a[edge_row:, :, i] == c)
+
+    @pytest.mark.parametrize("green_space", [
+        2, 3, 4,  # as int
+        2.0, 3.0, 4.0  # as float
+    ])
+    @pytest.mark.parametrize("explicit_default", [True, False])
+    def test_horizontal_box_spacing_two_colors(self, green_space,
+                                               explicit_default, render_page,
+                                               web_drivers):
+        # Creating a page with one box containing Color widgets
+        box = TestBox.FullViewportBox(direction=ww.Direction.HORIZONTAL)
+        if explicit_default:
+            box.add(TestBox.Color(color=(255, 0, 0)), space=1)
+        else:
+            box.add(TestBox.Color(color=(255, 0, 0)))
+        box.add(TestBox.Color(color=(0, 255, 0)), space=green_space)
+        page = ww.Page([box])
+
+        for web_driver in web_drivers:
+
+            # Rendering the page with the box
+            array = render_page(page, web_driver)
+
+            # Computing the expected red and green regions, avoiding the edge
+            # if colors cannot spread evenly
+            all_indices = np.arange(array.shape[1])
+            edge = array.shape[1] // (int(green_space) + 1)
+            red, green = np.split(all_indices, [edge])
+            if array.shape[1] % (int(green_space) + 1) != 0:
+                green = green[green != edge]
+
+            # Testing than first region is red and second region is green
+            assert np.all(array[:, red, 0] == 255)
+            assert np.all(array[:, red, 1] == 0)
+            assert np.all(array[:, red, 2] == 0)
+            assert np.all(array[:, green, 0] == 0)
+            assert np.all(array[:, green, 1] == 255)
+            assert np.all(array[:, green, 2] == 0)
+
+    @pytest.mark.parametrize("green_space", [
+        2, 3, 4,  # as int
+        2.0, 3.0, 4.0  # as float
+    ])
+    @pytest.mark.parametrize("explicit_default", [True, False])
+    def test_vertical_box_spacing_two_colors(self, green_space,
+                                             explicit_default, render_page,
+                                             web_drivers):
+        # Creating a page with one box containing Color widgets
+        box = TestBox.FullViewportBox(direction=ww.Direction.VERTICAL)
+        if explicit_default:
+            box.add(TestBox.Color(color=(255, 0, 0)), space=1)
+        else:
+            box.add(TestBox.Color(color=(255, 0, 0)))
+        box.add(TestBox.Color(color=(0, 255, 0)), space=green_space)
+        page = ww.Page([box])
+
+        for web_driver in web_drivers:
+
+            # Rendering the page with the box
+            array = render_page(page, web_driver)
+
+            # Computing the expected red and green regions, avoiding the edge
+            # if colors cannot spread evenly
+            all_indices = np.arange(array.shape[0])
+            edge = array.shape[0] // (int(green_space) + 1)
+            red, green = np.split(all_indices, [edge])
+            if array.shape[0] % (int(green_space) + 1) != 0:
+                green = green[green != edge]
+
+            # Testing than first region is red and second region is green
+            assert np.all(array[red, :, 0] == 255)
+            assert np.all(array[red, :, 1] == 0)
+            assert np.all(array[red, :, 2] == 0)
+            assert np.all(array[green, :, 0] == 0)
+            assert np.all(array[green, :, 1] == 255)
+            assert np.all(array[green, :, 2] == 0)
+
+    @pytest.mark.parametrize("spaces", [
+        (2, 2, 2, 2), (1, 2, 3, 4),
+        (1, 2, 2, 0.5), (1, 0.25, 0.75, 3)  # Mixed types
+    ])
+    def test_horizontal_box_spacing_more_colors(self, spaces, render_page,
+                                                web_drivers):
+        spaces = np.array(spaces)
+
+        # Creating a page with one box containing Color widgets
+        colors = [
+            (255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0)
+        ]
+        box = TestBox.FullViewportBox(direction=ww.Direction.HORIZONTAL)
+        for color, space in zip(colors, spaces):
+            box.add(TestBox.Color(color=color), space=space.item())
+        page = ww.Page([box])
+
+        for web_driver in web_drivers:
+
+            # Rendering the page with the box
+            array = render_page(page, web_driver)
+
+            # Computing the expected colored regions, avoiding all edges even
+            # if colors spread evenly
+            all_indices = np.arange(array.shape[1])
+            edges = array.shape[1] * (spaces.cumsum() / spaces.sum())[:-1]
+            edges = np.floor(edges).astype(np.int32)
+            regions = np.split(all_indices, edges)
+            regions = [r[~np.isin(r, edges)] for r in regions]
+
+            # Testing each region
+            for color, region in zip(colors, regions):
+                assert np.all(array[:, region, 0] == color[0])
+                assert np.all(array[:, region, 1] == color[1])
+                assert np.all(array[:, region, 2] == color[2])
+
+    @pytest.mark.parametrize("spaces", [
+        (2, 2, 2, 2), (1, 2, 3, 4),
+        (1, 2, 2, 0.5), (1, 0.25, 0.75, 3)  # Mixed types
+    ])
+    def test_vertical_box_spacing_more_colors(self, spaces, render_page,
+                                              web_drivers):
+        spaces = np.array(spaces)
+
+        # Creating a page with one box containing Color widgets
+        colors = [
+            (255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0)
+        ]
+        box = TestBox.FullViewportBox(direction=ww.Direction.VERTICAL)
+        for color, space in zip(colors, spaces):
+            box.add(TestBox.Color(color=color), space=space.item())
+        page = ww.Page([box])
+
+        for web_driver in web_drivers:
+
+            # Rendering the page with the box
+            array = render_page(page, web_driver)
+
+            # Computing the expected colored regions, avoiding all edges even
+            # if colors spread evenly
+            all_indices = np.arange(array.shape[0])
+            edges = array.shape[0] * (spaces.cumsum() / spaces.sum())[:-1]
+            edges = np.floor(edges).astype(np.int32)
+            regions = np.split(all_indices, edges)
+            regions = [r[~np.isin(r, edges)] for r in regions]
+
+            # Testing each region
+            for color, region in zip(colors, regions):
+                assert np.all(array[region, :, 0] == color[0])
+                assert np.all(array[region, :, 1] == color[1])
+                assert np.all(array[region, :, 2] == color[2])
+
+    def test_nested_boxes_with_uneven_spacing(self, render_page, web_drivers):
+        """Tests that two nested boxes with orthogonal directions and uneven
+        spacing rules render correctly.
+        """
+        top_box = TestBox.FullyExpandedBox(direction=ww.Direction.HORIZONTAL)
+        top_box.add(TestBox.Color(color=(255, 0, 0)))
+        top_box.add(TestBox.Color(color=(0, 255, 0)), space=3)
+        out_box = TestBox.FullViewportBox(direction=ww.Direction.VERTICAL)
+        out_box.add(top_box, space=0.5)
+        out_box.add(TestBox.Color(color=(0, 0, 255)))
+        page = ww.Page([out_box])
+
+        for web_driver in web_drivers:
+            a = render_page(page, web_driver)
+            for i, c in enumerate((255, 0, 0)):
+                assert np.all(a[:a.shape[0] // 3, :a.shape[1] // 4, i] == c)
+            edge_col = a.shape[1] // 4 + (0 if a.shape[1] % 4 == 0 else 1)
+            for i, c in enumerate((0, 255, 0)):
+                assert np.all(a[:a.shape[0] // 3, edge_col:, i] == c)
+            edge_row = a.shape[0] // 3 + (0 if a.shape[0] % 3 == 0 else 1)
+            for i, c in enumerate((0, 0, 255)):
+                assert np.all(a[edge_row:, :, i] == c)
+
+    @pytest.mark.parametrize("size", (3, 4, 5, 6))
+    @pytest.mark.parametrize("position", (0, 1, 2))
+    def test_horizontal_box_with_absolute_size(self, size, position,
+                                               render_page, web_drivers):
+        """Tests that a widget with absolute size renders with the requested
+        size and is not expanded. Multiple sizes and positions within the box
+        (first, middle, last) are tested.
+        """
+        # Creating a page with one box
+        colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255)]
+        spaces = [1, 1, 1]
+        spaces[position] = ww.Px(size)
+        box = TestBox.FullViewportBox(direction=ww.Direction.HORIZONTAL)
+        for _ in range(3):
+            box.add(TestBox.Color(color=colors.pop(0)), space=spaces.pop(0))
+        page = ww.Page([box])
+
+        for web_driver in web_drivers:
+
+            # Rendering the page with the box
+            array = render_page(page, web_driver)
+
+            # Computing the regions where to search for each color. If the two
+            # expanding colors cannot spread evenly (which happens when the
+            # remaining space for them has an odd size), we exclude all edges
+            # where one color stops and another starts.
+            all_indices = np.arange(array.shape[1])
+            half_remainder = (array.shape[1] - size) // 2
+            edges = [
+                [size, size + half_remainder],  # position = 0
+                [half_remainder, array.shape[1] - half_remainder],  # position = 1
+                [half_remainder, 2 * half_remainder]  # position = 2
+            ][position]
+            regions = np.split(all_indices, edges)
+            if (array.shape[1] - size) % 2 != 0:
+                regions = [r[~np.isin(r, edges)] for r in regions]
+
+            assert len(regions) == 3  # One region per color
+            for color, region in zip(((255, 0, 0), (0, 255, 0), (0, 0, 255)),
+                                     regions):
+                assert np.all(array[:, region, 0] == color[0])
+                assert np.all(array[:, region, 1] == color[1])
+                assert np.all(array[:, region, 2] == color[2])
+
+    @pytest.mark.parametrize("size", (3, 4, 5, 6))
+    @pytest.mark.parametrize("position", (0, 1, 2))
+    def test_vertical_box_with_absolute_size(self, size, position,
+                                             render_page, web_drivers):
+        """Tests that a widget with absolute size renders with the requested
+        size and is not expanded. Multiple sizes and positions within the box
+        (first, middle, last) are tested.
+        """
+        # Creating a page with one box
+        colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255)]
+        spaces = [1, 1, 1]
+        spaces[position] = ww.Px(size)
+        box = TestBox.FullViewportBox(direction=ww.Direction.VERTICAL)
+        for _ in range(3):
+            box.add(TestBox.Color(color=colors.pop(0)), space=spaces.pop(0))
+        page = ww.Page([box])
+
+        for web_driver in web_drivers:
+
+            # Rendering the page with the box
+            array = render_page(page, web_driver)
+
+            # Computing the regions where to search for each color. If the two
+            # expanding colors cannot spread evenly (which happens when the
+            # remaining space for them has an odd size), we exclude all edges
+            # where one color stops and another starts.
+            all_indices = np.arange(array.shape[0])
+            half_remainder = (array.shape[0] - size) // 2
+            edges = [
+                [size, size + half_remainder],  # position = 0
+                [half_remainder, array.shape[0] - half_remainder],  # position = 1
+                [half_remainder, 2 * half_remainder]  # position = 2
+            ][position]
+            regions = np.split(all_indices, edges)
+            if (array.shape[0] - size) % 2 != 0:
+                regions = [r[~np.isin(r, edges)] for r in regions]
+
+            assert len(regions) == 3  # One region per color
+            for color, region in zip(((255, 0, 0), (0, 255, 0), (0, 0, 255)),
+                                     regions):
+                assert np.all(array[region, :, 0] == color[0])
+                assert np.all(array[region, :, 1] == color[1])
+                assert np.all(array[region, :, 2] == color[2])
+
+    @pytest.mark.parametrize("direction", (
+        ww.Direction.HORIZONTAL, ww.Direction.VERTICAL
+    ))
+    def test_large_box_item_is_clipped(self, direction, render_page,
+                                       web_drivers):
+        """Tests that a large box item is clipped to respect the spacing rules
+        of the box.
+        """
+        # Defining the box. The large item has either a width of 50vw or a
+        # height of 50vh (depending on the direction), which is above the space
+        # allocated by the spacing rules (1/3), so it should be clipped to 1/3
+        # of the viewport
+        box = TestBox.FullViewportBox(direction=direction)
+        size_arg = {"width": "50vw"} if direction == ww.Direction.HORIZONTAL \
+            else {"height": "50vh"}
+        big_item = TestBox.Color(color=(255, 0, 0), **size_arg)
+        box.add(big_item, space=1)
+        box.add(TestBox.Color(color=(0, 255, 0)), space=2)
+
+        # Creating a page containing the box
+        page = ww.Page([box])
+
+        # Testing that the large item (colored in red) only occupies 1/3 of the
+        # box
+        for web_driver in web_drivers:
+            a = render_page(page, web_driver)
+            for i, c in enumerate((255, 0, 0)):
+                if direction == ww.Direction.HORIZONTAL:
+                    assert np.all(a[:, :a.shape[1] // 3, i] == c)
+                else:
+                    assert np.all(a[:a.shape[0] // 3, :, i] == c)
+            axis = 1 if direction == ww.Direction.HORIZONTAL else 0
+            edge = a.shape[axis] // 3 + (0 if a.shape[axis] % 3 == 0 else 1)
+            for i, c in enumerate((0, 255, 0)):
+                if direction == ww.Direction.HORIZONTAL:
+                    assert np.all(a[:, edge:, i] == c)
+                else:
+                    assert np.all(a[edge:, :, i] == c)
+
+
+class TestBoxItemProperties:
+    @pytest.mark.parametrize("space", [4, 5.1, 0.2])
+    def test_to_style_numeric(self, space):
+        props = BoxItemProperties(space=space)
+        assert props.to_style() == {
+            'flex-basis': "0",
+            'flex-grow': str(space),
+            'flex-shrink': str(space)
+        }
+
+    @pytest.mark.parametrize("space", [ww.Px(4), ww.Px(3.5)])
+    def test_to_style_absolute_size(self, space):
+        props = BoxItemProperties(space=space)
+        assert props.to_style() == {
+            'flex-basis': f"{space.value}px",
+            'flex-grow': "0",
+            'flex-shrink': "0"
+        }

{webwidgets-1.1.0 → webwidgets-1.1.1}/webwidgets/__init__.py

@@ -10,9 +10,11 @@
 #
 # =======================================================================
 
-__version__ = "1.1.0"  # Dynamically set by build backend
+__version__ = "1.1.1"  # Dynamically set by build backend
 
 from . import compilation
 from . import utility
+from .utility.enums import *
+from .utility.sizes.sizes import *
 from .website import *
 from .widgets import *

{webwidgets-1.1.0 → webwidgets-1.1.1}/webwidgets/compilation/css/css.py

@@ -170,7 +170,7 @@ def compile_css(trees: Union[HTMLNode, List[HTMLNode]],
         Every HTML node present in one or more of the input trees is included
         in the :py:attr:`CompiledCSS.mapping` attribute, even if the node does
         not have a style. Rules are alphabetically ordered by class name in the
-        mapping.
+        mapping and in the :py:attr:`CompiledCSS.core` rule section.
     :rtype: CompiledCSS
     """
     # Handling case of a single tree

{webwidgets-1.1.0 → webwidgets-1.1.1}/webwidgets/compilation/css/css_rule.py

@@ -13,7 +13,8 @@
 from typing import Dict
 from webwidgets.utility.indentation import get_indentation
 from webwidgets.utility.representation import ReprMixin
-from webwidgets.utility.validation import validate_css_identifier, validate_css_selector
+from webwidgets.utility.validation import validate_css_identifier, \
+    validate_css_selector, validate_css_value
 
 
 class CSSRule(ReprMixin):
@@ -60,6 +61,7 @@ class CSSRule(ReprMixin):
         css_code = self.selector + " {\n"
         for property_name, value in self.declarations.items():
             validate_css_identifier(property_name)
+            validate_css_value(value)
             css_code += f"{indentation}{property_name}: {value};\n"
         css_code += "}"