Struct Constraint

pub struct Constraint {
    pub width: DimensionValue,
    pub height: DimensionValue,
}

Represents layout constraints for a component node.

A Constraint combines width and height dimension values to provide complete layout specification for a component. It defines how a component should size itself in both dimensions and provides methods for merging constraints in a component hierarchy.

Examples

// A button with fixed size
let button_constraint = Constraint::new(
    DimensionValue::Fixed(Px(120)),
    DimensionValue::Fixed(Px(40))
);

// A flexible container that fills width but wraps height
let container_constraint = Constraint::new(
    DimensionValue::Fill { min: Some(Px(200)), max: None },
    DimensionValue::Wrap { min: None, max: None }
);

// A text component with bounded wrapping
let text_constraint = Constraint::new(
    DimensionValue::Wrap { min: Some(Px(100)), max: Some(Px(400)) },
    DimensionValue::Wrap { min: None, max: None }
);

Fields

width: DimensionValue

The width dimension constraint

height: DimensionValue

The height dimension constraint

Implementations

impl Constraint

pub const NONE: Self

A constraint that specifies no preference (Wrap { None, None } for both width and height).

This constant represents the most flexible constraint possible, where a component will size itself to its content without any bounds. It’s equivalent to the default constraint and is useful as a starting point for constraint calculations.

Example

let flexible = Constraint::NONE;
assert_eq!(flexible.width, DimensionValue::Wrap { min: None, max: None });
assert_eq!(flexible.height, DimensionValue::Wrap { min: None, max: None });

pub fn new(width: DimensionValue, height: DimensionValue) -> Self

Creates a new constraint with the specified width and height dimensions.

This is the primary constructor for creating constraint instances.

Parameters

• width: The dimension value for the width constraint
• height: The dimension value for the height constraint

Example

let constraint = Constraint::new(
    DimensionValue::Fixed(Px(100)),
    DimensionValue::Fill { min: Some(Px(50)), max: None }
);

pub fn merge(&self, parent_constraint: &Constraint) -> Self

Merges this constraint with a parent constraint to resolve layout conflicts.

This method implements the core constraint resolution algorithm used throughout Tessera’s layout system. When components are nested, their constraints must be merged to ensure consistent and predictable layout behavior.

Merge Rules

The merging follows a priority system designed to respect component intentions while ensuring layout consistency:

Fixed Constraints (Highest Priority)

• Fixed always wins: A fixed constraint cannot be overridden by its parent
• Fixed dimensions maintain their exact size regardless of available space

Wrap Constraints (Content-Based)

• Preserves content sizing: Wrap constraints maintain their intrinsic sizing behavior
• When parent is Fixed: Child wraps within parent’s fixed bounds
• When parent is Wrap: Child combines min/max constraints with parent
• When parent is Fill: Child wraps within parent’s fill bounds

Fill Constraints (Space-Filling)

• Adapts to available space: Fill constraints expand within parent bounds
• When parent is Fixed: Child fills parent’s fixed space (respecting own min/max)
• When parent is Wrap: Child fills available space within parent’s wrap bounds
• When parent is Fill: Child combines fill constraints with parent

Parameters

• parent_constraint: The constraint from the parent component

Returns

A new constraint that represents the resolved layout requirements

Examples

// Fixed child in fixed parent - child wins
let parent = Constraint::new(
    DimensionValue::Fixed(Px(200)),
    DimensionValue::Fixed(Px(200))
);
let child = Constraint::new(
    DimensionValue::Fixed(Px(100)),
    DimensionValue::Fixed(Px(100))
);
let merged = child.merge(&parent);
assert_eq!(merged.width, DimensionValue::Fixed(Px(100)));

// Fill child in fixed parent - child fills parent's space
let child_fill = Constraint::new(
    DimensionValue::Fill { min: Some(Px(50)), max: None },
    DimensionValue::Fill { min: Some(Px(50)), max: None }
);
let merged_fill = child_fill.merge(&parent);
assert_eq!(merged_fill.width, DimensionValue::Fill {
    min: Some(Px(50)),
    max: Some(Px(200))
});

Trait Implementations

impl Clone for Constraint

fn clone(&self) -> Constraint

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Constraint

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Constraint

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Constraint

fn eq(&self, other: &Constraint) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Constraint

impl Eq for Constraint

impl StructuralPartialEq for Constraint