🥮 mooncakes.io
    Sign in

    mizchi/crater-layout/types does not have a README file

    AlignSelf

    source
    pub(all) enum AlignSelf {
      Auto
      Start
      End
      Center
      Stretch
      Baseline
    } derive(Eq, 
    Debug    )

    Align-self value (can override align-items for individual items)
    impl Show for AlignSelf

    Alignment

    source
    pub(all) enum Alignment {
      Start
      End
      Left
      Right
      FlexStart
      FlexEnd
      Center
      SpaceBetween
      SpaceAround
      SpaceEvenly
      Stretch
      Baseline
    } derive(Eq, 
    Debug    )

    Alignment for justify-content, align-items, etc. Note: Start/End are physical/logical directions (not affected by flex-wrap direction) FlexStart/FlexEnd are flex-relative (affected by wrap-reverse)
    impl Show for Alignment

    BackgroundImage

    source
    pub(all) enum BackgroundImage {
      None
      Gradient(LinearGradient)
    }

    Background image (currently only linear-gradient)

    BoundingRect

    source
    pub(all) struct BoundingRect {
      x : Double
      y : Double
      width : Double
      height : Double
    }

    BoundingRect - the output of layout computation Matches browser's getBoundingClientRect()

    BoundingRect::area

    source
    fn BoundingRect::area(self : BoundingRect) -> Double

    Calculate the area of the bounding rect

    BoundingRect::bottom

    source
    fn BoundingRect::bottom(self : BoundingRect) -> Double

    Get the bottom edge (y + height)

    BoundingRect::new

    source
    fn BoundingRect::new(x : Double, y : Double, width : Double, height : Double) -> BoundingRect

    BoundingRect::right

    source
    fn BoundingRect::right(self : BoundingRect) -> Double

    Get the right edge (x + width)

    BoundingRect::union

    source
    fn BoundingRect::union(self : BoundingRect, other : BoundingRect) -> BoundingRect

    Calculate union of two bounding rects

    BoundingRect::zero

    source

    BoxSizing

    source
    pub(all) enum BoxSizing {
      ContentBox
      BorderBox
    } derive(Eq, 
    Debug    )

    CSS box-sizing property
    impl Show for BoxSizing

    Clear

    source
    pub(all) enum Clear {
      None
      Left
      Right
      Both
    } derive(Eq, 
    Debug    )

    CSS clear property
    impl Show for Clear

    ClipRect

    source
    pub(all) enum ClipRect {
      Auto
      Rect(Double, Double, Double, Double)
    } derive(Eq)

    CSS clip property value clip: rect(top, right, bottom, left) or auto Note: This is a deprecated property, but still widely used for accessibility
    impl Show for ClipRect

    ClipRect::default

    source
    fn ClipRect::default() -> ClipRect

    Color

    source
    pub(all) struct Color {
      r : Int
      g : Int
      b : Int
      a : Double
    }

    RGBA color with 8-bit channels and alpha
    impl Eq for Color
    impl Show for Color

    Color::black

    source
    fn Color::black() -> Color

    Black color

    Color::is_opaque

    source
    fn Color::is_opaque(self : Color) -> Bool

    Color::is_transparent

    source
    fn Color::is_transparent(self : Color) -> Bool

    Color::rgb

    source
    fn Color::rgb(r : Int, g : Int, b : Int) -> Color

    Color::rgba

    source
    fn Color::rgba(r : Int, g : Int, b : Int, a : Double) -> Color

    Color::to_hex

    source
    fn Color::to_hex(self : Color) -> String

    Convert to CSS hex string (#rrggbb or #rrggbbaa)

    Color::to_rgba_string

    source
    fn Color::to_rgba_string(self : Color) -> String

    Convert to CSS rgba() string

    Color::transparent

    source
    fn Color::transparent() -> Color

    Transparent color (alpha = 0)

    Color::white

    source
    fn Color::white() -> Color

    White color

    Dimension

    source
    pub(all) enum Dimension {
      Length(Double)
      Percent(Double)
      Auto
      MinContent
      MaxContent
      FitContent(Double)
    } derive(Eq)

    CSS dimension value: length, percentage, auto, or intrinsic sizing keywords
    impl Show for Dimension

    Dimension::eq_length

    source
    fn Dimension::eq_length(self : Dimension, value : Double) -> Bool

    Check if dimension equals a specific length value

    Dimension::eq_percent

    source
    fn Dimension::eq_percent(self : Dimension, value : Double) -> Bool

    Check if dimension equals a specific percent value

    Dimension::is_definite

    source
    fn Dimension::is_definite(self : Dimension) -> Bool

    Check if dimension is a definite value (Length or Percent)

    Dimension::is_intrinsic

    source
    fn Dimension::is_intrinsic(self : Dimension) -> Bool

    Check if dimension requires intrinsic sizing

    Dimension::resolve

    source
    fn Dimension::resolve(self : Dimension, context : Double) -> Double?

    Resolve dimension to concrete value context: parent size for percentage calculation Note: MinContent, MaxContent, FitContent return None - they need intrinsic size calculation

    Dimension::resolve_or

    source
    fn Dimension::resolve_or(self : Dimension, context : Double, fallback : Double) -> Double

    Resolve with fallback value for Auto

    Dimension::resolve_or_intrinsic

    source
    fn Dimension::resolve_or_intrinsic(self : Dimension, context : Double, fallback : Double) -> Double

    Resolve dimension to length, treating intrinsic keywords as fallback

    Display

    source
    pub(all) enum Display {
      Block
      Inline
      InlineBlock
      Flex
      InlineFlex
      Grid
      InlineGrid
      Table
      InlineTable
      TableRow
      TableCell
      TableCaption
      TableRowGroup
      TableHeaderGroup
      TableFooterGroup
      TableColumn
      TableColumnGroup
      None
      Contents
      FlowRoot
    } derive(Eq, 
    Debug    )

    CSS display property
    impl Show for Display

    FlexDirection

    source
    pub(all) enum FlexDirection {
      Row
      RowReverse
      Column
      ColumnReverse
    } derive(Eq, 
    Debug    )

    Flex direction

    FlexWrap

    source
    pub(all) enum FlexWrap {
      NoWrap
      Wrap
      WrapReverse
    } derive(Eq, 
    Debug    )

    Flex wrap mode
    impl Show for FlexWrap

    Float

    source
    pub(all) enum Float {
      None
      Left
      Right
    } derive(Eq, 
    Debug    )

    CSS float property
    impl Show for Float

    GradientStop

    source
    pub(all) struct GradientStop {
      color : Color
      position : Double
    }

    A color stop in a gradient

    GridAutoFlow

    source
    pub(all) enum GridAutoFlow {
      Row
      Column
      RowDense
      ColumnDense
    } derive(Eq, 
    Debug    )

    Grid auto-flow direction

    GridLine

    source
    pub(all) struct GridLine {
      start : GridPlacement
      end : GridPlacement
    } derive(Eq, 
    Debug    )

    Grid line range (start and end)
    impl Show for GridLine

    GridLine::auto

    source
    fn GridLine::auto() -> GridLine

    GridPlacement

    source
    pub(all) enum GridPlacement {
      Auto
      Line(Int)
      Span(Int)
    } derive(Eq, 
    Debug    )

    Grid line placement for grid items

    IntrinsicSize

    source
    pub(all) struct IntrinsicSize {
      min_width : Double
      max_width : Double
      min_height : Double
      max_height : Double
    }

    Intrinsic size measurement result

    IntrinsicSize::default

    source
    fn IntrinsicSize::default() -> IntrinsicSize

    Default intrinsic size for leaf nodes without measure function Matches Taffy behavior: empty/unmeasured nodes have zero intrinsic size

    Layout

    source
    pub(all) struct Layout {
      id : String
      x : Double
      y : Double
      width : Double
      height : Double
      margin : Rect[Double]
      padding : Rect[Double]
      border : Rect[Double]
      overflow_x : Overflow
      overflow_y : Overflow
      scroll_width : Double
      scroll_height : Double
      children : Array[Layout]
      text : String?
    }

    Complete layout result for a node

    Layout::to_bounding_rect

    source
    fn Layout::to_bounding_rect(self : Layout) -> BoundingRect

    LayoutContext

    source
    pub(all) struct LayoutContext {
      available_width : Double
      available_height : Double?
      sizing_mode : SizingMode
      viewport_width : Double
      viewport_height : Double
      stretch_width : Bool
      stretch_height : Bool
    }

    Context for layout computation

    LayoutResult

    source
    pub(all) struct LayoutResult {
      layout : Layout
      warnings : Array[LayoutWarning]
    }

    Result of layout computation with warnings

    LayoutWarning

    source
    pub(all) enum LayoutWarning {
      UnsupportedFloat(String)
      UnsupportedPosition(String)
      UnsupportedDisplay(String)
    } derive(
    Debug    )

    Warnings emitted during layout computation

    Line

    source
    pub struct Line[T] {
      start : T
      end : T
    }

    A line segment with start and end points
    impl Show for Line[T]

    Line::new

    source
    fn[T] Line::new(start : T, end : T) -> Line[T]

    LinearGradient

    source
    pub(all) struct LinearGradient {
      angle_deg : Double
      stops : Array[GradientStop]
    }

    Linear gradient with angle and color stops

    MaxTrackSizing

    source
    pub(all) enum MaxTrackSizing {
      Length(Double)
      Percent(Double)
      Fr(Double)
      Auto
      MinContent
      MaxContent
    } derive(Eq, 
    Debug    )

    Maximum track sizing function for minmax()

    MeasureFunc

    source
    pub(all) struct MeasureFunc {
      func : (Double, Double) -> IntrinsicSize
    }

    Measure function type - called to determine intrinsic size of a node Parameters: (available_width, available_height) -> IntrinsicSize

    MinTrackSizing

    source
    pub(all) enum MinTrackSizing {
      Length(Double)
      Percent(Double)
      Auto
      MinContent
      MaxContent
    } derive(Eq, 
    Debug    )

    Minimum track sizing function for minmax()

    Overflow

    source
    pub(all) enum Overflow {
      Visible
      Hidden
      Clip
      Scroll
      Auto
    } derive(Eq, 
    Debug    )

    CSS overflow property
    impl Show for Overflow

    Point

    source
    pub struct Point[T] {
      x : T
      y : T
    }

    2D point with x and y coordinates
    impl Show for Point[T]

    Point::map

    source
    fn[T, U] Point::map(self : Point[T], f : (T) -> U) -> Point[U]

    Point::new

    source
    fn[T] Point::new(x : T, y : T) -> Point[T]

    Point::zero

    source
    fn Point::zero() -> Point[Double]

    Position

    source
    pub(all) enum Position {
      Static
      Relative
      Absolute
      Fixed
    } derive(Eq, 
    Debug    )

    CSS position property
    impl Show for Position

    Rect

    source
    pub(all) struct Rect[T] {
      left : T
      right : T
      top : T
      bottom : T
    }

    Rectangle with left, right, top, bottom edges Used for margin, padding, border, inset
    impl Show for Rect[T]

    Rect::all

    source
    fn[T] Rect::all(value : T) -> Rect[T]

    Create a rect with all sides set to the same value

    Rect::horizontal_sum

    source
    fn Rect::horizontal_sum(self : Rect[Double]) -> Double

    Sum of left and right (horizontal axis)

    Rect::map

    source
    fn[T, U] Rect::map(self : Rect[T], f : (T) -> U) -> Rect[U]

    Rect::new

    source
    fn[T] Rect::new(left : T, right : T, top : T, bottom : T) -> Rect[T]

    Rect::vertical_sum

    source
    fn Rect::vertical_sum(self : Rect[Double]) -> Double

    Sum of top and bottom (vertical axis)

    Rect::zero

    source
    fn Rect::zero() -> Rect[Double]

    RepeatCount

    source
    pub(all) enum RepeatCount {
      Count(Int)
      AutoFill
      AutoFit
    } derive(Eq, 
    Debug    )

    Repeat count for repeat() function
    impl Show for RepeatCount

    SingleTrackSizing

    source
    pub(all) enum SingleTrackSizing {
      Length(Double)
      Percent(Double)
      Fr(Double)
      Auto
      MinContent
      MaxContent
      MinMax(MinTrackSizing, MaxTrackSizing)
      FitContentLength(Double)
      FitContentPercent(Double)
    } derive(Eq, 
    Debug    )

    Single track sizing function (non-repeating)

    Size

    source
    pub struct Size[T] {
      width : T
      height : T
    }

    2D size with width and height
    impl Show for Size[T]

    Size::map

    source
    fn[T, U] Size::map(self : Size[T], f : (T) -> U) -> Size[U]

    Size::new

    source
    fn[T] Size::new(width : T, height : T) -> Size[T]

    Size::zero

    source
    fn Size::zero() -> Size[Double]

    SizingMode

    source
    pub(all) enum SizingMode {
      Definite
      MaxContent
    } derive(Eq)

    Sizing mode for layout computation Definite: Use available space (normal flow) MaxContent: Use intrinsic max-content (shrink-to-fit)

    TrackSizingFunction

    source
    pub(all) enum TrackSizingFunction {
      Length(Double)
      Percent(Double)
      Fr(Double)
      Auto
      MinContent
      MaxContent
      MinMax(MinTrackSizing, MaxTrackSizing)
      Repeat(RepeatCount, Array[SingleTrackSizing])
      FitContentLength(Double)
      FitContentPercent(Double)
    } derive(Eq, 
    Debug    )

    Track sizing function for grid-template-rows/columns

    apply_aspect_ratio_height

    source
    fn apply_aspect_ratio_height(width : Double, aspect_ratio : Double?) -> Double?

    Apply aspect ratio to calculate height from width. Returns height if aspect_ratio is defined, otherwise returns None.

    apply_aspect_ratio_width

    source
    fn apply_aspect_ratio_width(height : Double, aspect_ratio : Double?) -> Double?

    Apply aspect ratio to calculate width from height. Returns width if aspect_ratio is defined, otherwise returns None.

    clamp

    source
    fn clamp(value : Double, min_val : Double, max_val : Double) -> Double

    Clamp a value between min and max CSS spec: min takes precedence over max when they conflict So apply max first (value cannot exceed max), then min (value cannot go below min)

    max

    source
    fn max(a : Double, b : Double) -> Double

    min

    source
    fn min(a : Double, b : Double) -> Double

    resolve_dimensions_with_aspect_ratio

    source
    fn resolve_dimensions_with_aspect_ratio(width : Double?, height : Double?, aspect_ratio : Double?, min_width : Double, max_width : Double, min_height : Double, max_height : Double) -> (Double?, Double?)

    Resolve dimensions with aspect ratio. Given known dimension (width or height), aspect_ratio, and min/max constraints, returns the final (width, height) pair.

    • If width is known, height = width / aspect_ratio
    • If height is known, width = height * aspect_ratio
    • If both are known, aspect_ratio overrides the height
    • Min/max constraints are applied after aspect ratio calculation

    resolve_rect

    source
    fn resolve_rect(rect : Rect[Dimension], parent_width : Double) -> Rect[Double]

    Resolve a Rect[Dimension] (margin/padding/border) to Rect[Double] Uses parent_width for percentage resolution (CSS spec: percentages resolve against width)

    resolve_rect_intrinsic

    source
    fn resolve_rect_intrinsic(rect : Rect[Dimension]) -> Rect[Double]

    Resolve a dimension rect for intrinsic sizing Percentages resolve to 0 in intrinsic sizing contexts

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io