Sign in

    moon_taffy

    MoonBit port of the Rust crate taffy (v0.5.x)

    layout
    flexbox
    css
    Download zip
    Author
    Version
    0.1.24
    License
    Apache-2.0
    Last updated
    8 months ago
    Downloads
    15K

    No dependencies

    #Milky2018/moon_taffy

    MoonBit port (in-progress) of the Rust crate taffy (UI layout engine).

    • Upstream pinned: taffy v0.5.2 (see UPSTREAM.md)
    • Current status: very small compatibility slice (enough for initial upstream tests)

    #Quick start

    ///|
    test {
    let taffy : @Milky2018/moon_taffy.TaffyTree[Unit] = @Milky2018/moon_taffy.TaffyTree::new()
    let child = taffy.new_leaf(@Milky2018/moon_taffy.Style::default())
    let root = taffy.new_with_children(
    @Milky2018/moon_taffy.Style::default().with_size(
    @Milky2018/moon_taffy.Size::new(
    width=@Milky2018/moon_taffy.length(100.0),
    height=@Milky2018/moon_taffy.length(100.0),
    ),
    ),
    [child],
    )
    taffy.compute_layout(root, @Milky2018/moon_taffy.Size::max_content())
    let layout = taffy.layout(root)
    assert_eq(layout.size.width, 100.0)
    assert_eq(layout.size.height, 100.0)
    }

    NodeId

    type NodeId = Int

    TaffyError

    type TaffyError

    AlignContent

    #alias(JustifyContent)
    pub enum AlignContent {
    AlignStart
    AlignEnd
    AlignFlexStart
    AlignFlexEnd
    AlignCenter
    AlignStretch
    AlignSpaceBetween
    AlignSpaceEvenly
    AlignSpaceAround
    }

    AlignItems

    #alias(JustifyItems)
    #alias(AlignSelf)
    #alias(JustifySelf)
    pub enum AlignItems {
    ItemsStart
    ItemsEnd
    ItemsFlexStart
    ItemsFlexEnd
    ItemsCenter
    ItemsBaseline
    ItemsStretch
    }

    AvailableSpace

    pub enum AvailableSpace {
    AvailDefinite(Double)
    AvailMinContent
    AvailMaxContent
    }

    Dimension

    pub enum Dimension {
    DimAuto
    DimLength(Double)
    DimPercent(Double)
    DimFr(Double)
    DimMinMax(Dimension, Dimension)
    DimMinContent
    DimMaxContent
    DimFitContent(Dimension)
    DimRepeat(GridTrackRepetition, Array[Dimension])
    }

    Display

    pub enum Display {
    DisplayBlock
    DisplayFlex
    DisplayGrid
    DisplayNone
    }

    FlexDirection

    pub enum FlexDirection {
    FlexRow
    FlexRowReverse
    FlexColumn
    FlexColumnReverse
    }

    FlexWrap

    pub enum FlexWrap {
    FlexNoWrap
    FlexWrap
    FlexWrapReverse
    }

    GridAutoFlow

    pub enum GridAutoFlow {
    Row
    Column
    RowDense
    ColumnDense
    }

    GridPlacement

    pub enum GridPlacement {
    PlaceAuto
    PlaceLine(Int)
    PlaceSpan(Int)
    }

    GridTrackRepetition

    pub enum GridTrackRepetition {
    RepeatCount(Int)
    RepeatAutoFill
    RepeatAutoFit
    }

    Layout

    pub struct Layout {
    location : Point[Double]
    size : Size[Double]
    }

    Layout::zero

    fn Layout::zero() -> Layout

    Line

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

    Line::new

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

    Node

    type Node[C]

    Overflow

    pub enum Overflow {
    OverflowVisible
    OverflowClip
    OverflowHidden
    OverflowScroll
    }

    Point

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

    Point::new

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

    Point::zero

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

    Position

    pub enum Position {
    PosRelative
    PosAbsolute
    }

    Rect

    pub struct Rect[T] {
    left : T
    right : T
    top : T
    bottom : T
    }

    Rect::new

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

    Size

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

    Size::max_content

    fn Size::max_content() -> Size[AvailableSpace]

    Size::new

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

    Size::zero

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

    Style

    pub struct Style {
    display : Display
    overflow : Point[Overflow]
    scrollbar_width : Double
    position : Position
    inset : Rect[Dimension]
    size : Size[Dimension]
    min_size : Size[Dimension]
    max_size : Size[Dimension]
    aspect_ratio : Double?
    margin : Rect[Dimension]
    padding : Rect[Dimension]
    border : Rect[Dimension]
    align_items : AlignItems?
    align_self : AlignItems?
    justify_items : AlignItems?
    justify_self : AlignItems?
    align_content : AlignContent?
    justify_content : AlignContent?
    gap : Size[Dimension]
    flex_direction : FlexDirection
    flex_wrap : FlexWrap
    flex_basis : Dimension
    flex_grow : Double
    flex_shrink : Double
    grid_template_rows : Array[Dimension]
    grid_template_columns : Array[Dimension]
    grid_auto_rows : Array[Dimension]
    grid_auto_columns : Array[Dimension]
    grid_auto_flow : GridAutoFlow
    grid_row : Line[GridPlacement]
    grid_column : Line[GridPlacement]
    grid_row_start : Int?
    grid_column_start : Int?
    }

    Style::default

    fn Style::default() -> Style

    Style::with_align_content

    fn Style::with_align_content(self : Style, align_content : AlignContent) -> Style

    Style::with_align_items

    fn Style::with_align_items(self : Style, align_items : AlignItems) -> Style

    Style::with_align_self

    fn Style::with_align_self(self : Style, align_self : AlignItems) -> Style

    Style::with_aspect_ratio

    fn Style::with_aspect_ratio(self : Style, aspect_ratio : Double) -> Style

    Style::with_border

    fn Style::with_border(self : Style, border : Rect[Dimension]) -> Style

    Style::with_display

    fn Style::with_display(self : Style, display : Display) -> Style

    Style::with_flex_basis

    fn Style::with_flex_basis(self : Style, flex_basis : Dimension) -> Style

    Style::with_flex_direction

    fn Style::with_flex_direction(self : Style, flex_direction : FlexDirection) -> Style

    Style::with_flex_grow

    fn Style::with_flex_grow(self : Style, flex_grow : Double) -> Style

    Style::with_flex_shrink

    fn Style::with_flex_shrink(self : Style, flex_shrink : Double) -> Style

    Style::with_flex_wrap

    fn Style::with_flex_wrap(self : Style, flex_wrap : FlexWrap) -> Style

    Style::with_gap

    fn Style::with_gap(self : Style, gap : Size[Dimension]) -> Style

    Style::with_grid_auto_columns

    fn Style::with_grid_auto_columns(self : Style, grid_auto_columns : Array[Dimension]) -> Style

    Style::with_grid_auto_flow

    fn Style::with_grid_auto_flow(self : Style, grid_auto_flow : GridAutoFlow) -> Style

    Style::with_grid_auto_rows

    fn Style::with_grid_auto_rows(self : Style, grid_auto_rows : Array[Dimension]) -> Style

    Style::with_grid_column

    fn Style::with_grid_column(self : Style, grid_column : Line[GridPlacement]) -> Style

    Style::with_grid_column_start

    fn Style::with_grid_column_start(self : Style, start : Int) -> Style

    Style::with_grid_row

    fn Style::with_grid_row(self : Style, grid_row : Line[GridPlacement]) -> Style

    Style::with_grid_row_start

    fn Style::with_grid_row_start(self : Style, start : Int) -> Style

    Style::with_grid_template_columns

    fn Style::with_grid_template_columns(self : Style, grid_template_columns : Array[Dimension]) -> Style

    Style::with_grid_template_rows

    fn Style::with_grid_template_rows(self : Style, grid_template_rows : Array[Dimension]) -> Style

    Style::with_inset

    fn Style::with_inset(self : Style, inset : Rect[Dimension]) -> Style

    Style::with_justify_content

    fn Style::with_justify_content(self : Style, justify_content : AlignContent) -> Style

    Style::with_justify_items

    fn Style::with_justify_items(self : Style, justify_items : AlignItems) -> Style

    Style::with_justify_self

    fn Style::with_justify_self(self : Style, justify_self : AlignItems) -> Style

    Style::with_margin

    fn Style::with_margin(self : Style, margin : Rect[Dimension]) -> Style

    Style::with_max_size

    fn Style::with_max_size(self : Style, max_size : Size[Dimension]) -> Style

    Style::with_min_size

    fn Style::with_min_size(self : Style, min_size : Size[Dimension]) -> Style

    Style::with_overflow

    fn Style::with_overflow(self : Style, overflow : Point[Overflow]) -> Style

    Style::with_padding

    fn Style::with_padding(self : Style, padding : Rect[Dimension]) -> Style

    Style::with_position

    fn Style::with_position(self : Style, position : Position) -> Style

    Style::with_scrollbar_width

    fn Style::with_scrollbar_width(self : Style, scrollbar_width : Double) -> Style

    Style::with_size

    fn Style::with_size(self : Style, size : Size[Dimension]) -> Style

    TaffyTree

    pub struct TaffyTree[C] {
    // private fields
    }

    TaffyTree::add_child

    fn[C] TaffyTree::add_child(self : TaffyTree[C], parent : Int, child : Int) -> Unit raise TaffyError

    TaffyTree::clear_node_context

    fn[C] TaffyTree::clear_node_context(self : TaffyTree[C], node : Int) -> Unit raise TaffyError

    TaffyTree::compute_layout

    fn[C] TaffyTree::compute_layout(self : TaffyTree[C], root : Int, available_space : Size[AvailableSpace]) -> Unit raise TaffyError

    TaffyTree::compute_layout_with_measure

    fn[C] TaffyTree::compute_layout_with_measure(self : TaffyTree[C], root : Int, available_space : Size[AvailableSpace], measure_function : (Size[Double?], Size[AvailableSpace], Int, C?, Style) -> Size[Double]) -> Unit raise TaffyError

    TaffyTree::dirty

    fn[C] TaffyTree::dirty(self : TaffyTree[C], node : Int) -> Bool raise TaffyError

    TaffyTree::layout

    fn[C] TaffyTree::layout(self : TaffyTree[C], node : Int) -> Layout raise TaffyError

    TaffyTree::mark_dirty

    fn[C] TaffyTree::mark_dirty(self : TaffyTree[C], node : Int) -> Unit raise TaffyError

    TaffyTree::new

    fn[C] TaffyTree::new() -> TaffyTree[C]

    TaffyTree::new_leaf

    fn[C] TaffyTree::new_leaf(self : TaffyTree[C], style : Style) -> Int

    TaffyTree::new_leaf_with_context

    fn[C] TaffyTree::new_leaf_with_context(self : TaffyTree[C], style : Style, context : C) -> Int

    TaffyTree::new_with_children

    fn[C] TaffyTree::new_with_children(self : TaffyTree[C], style : Style, children : Array[Int]) -> Int

    TaffyTree::remove

    fn[C] TaffyTree::remove(self : TaffyTree[C], node : Int) -> Unit raise TaffyError

    TaffyTree::remove_child

    fn[C] TaffyTree::remove_child(self : TaffyTree[C], parent : Int, child : Int) -> Int raise TaffyError

    TaffyTree::remove_subtree

    fn[C] TaffyTree::remove_subtree(self : TaffyTree[C], node : Int) -> Unit raise TaffyError

    TaffyTree::set_children

    fn[C] TaffyTree::set_children(self : TaffyTree[C], parent : Int, children : Array[Int]) -> Unit raise TaffyError

    TaffyTree::set_node_context

    fn[C] TaffyTree::set_node_context(self : TaffyTree[C], node : Int, context : C) -> Unit raise TaffyError

    TaffyTree::set_style

    fn[C] TaffyTree::set_style(self : TaffyTree[C], node : Int, style : Style) -> Unit raise TaffyError

    TaffyTree::with_capacity

    fn[C] TaffyTree::with_capacity(_capacity : Int) -> TaffyTree[C]

    align_content_center

    fn align_content_center() -> AlignContent

    align_content_end

    fn align_content_end() -> AlignContent

    align_content_flex_end

    fn align_content_flex_end() -> AlignContent

    align_content_flex_start

    fn align_content_flex_start() -> AlignContent

    align_content_space_around

    fn align_content_space_around() -> AlignContent

    align_content_space_between

    fn align_content_space_between() -> AlignContent

    align_content_space_evenly

    fn align_content_space_evenly() -> AlignContent

    align_content_start

    fn align_content_start() -> AlignContent

    align_content_stretch

    fn align_content_stretch() -> AlignContent

    align_items_baseline

    fn align_items_baseline() -> AlignItems

    align_items_center

    fn align_items_center() -> AlignItems

    align_items_end

    fn align_items_end() -> AlignItems

    align_items_flex_end

    fn align_items_flex_end() -> AlignItems

    align_items_flex_start

    fn align_items_flex_start() -> AlignItems

    align_items_start

    fn align_items_start() -> AlignItems

    align_items_stretch

    fn align_items_stretch() -> AlignItems

    auto

    fn auto() -> Dimension

    available_space_definite

    fn available_space_definite(value : Double) -> AvailableSpace

    display_block

    fn display_block() -> Display

    display_flex

    fn display_flex() -> Display

    display_grid

    fn display_grid() -> Display

    display_none

    fn display_none() -> Display

    fit_content

    fn fit_content(limit : Dimension) -> Dimension

    flex_direction_column

    fn flex_direction_column() -> FlexDirection

    flex_direction_column_reverse

    fn flex_direction_column_reverse() -> FlexDirection

    flex_direction_row

    fn flex_direction_row() -> FlexDirection

    flex_direction_row_reverse

    fn flex_direction_row_reverse() -> FlexDirection

    flex_wrap_no_wrap

    fn flex_wrap_no_wrap() -> FlexWrap

    flex_wrap_wrap

    fn flex_wrap_wrap() -> FlexWrap

    flex_wrap_wrap_reverse

    fn flex_wrap_wrap_reverse() -> FlexWrap

    fn fr(value : Double) -> Dimension

    grid_auto_flow_column

    fn grid_auto_flow_column() -> GridAutoFlow

    grid_auto_flow_column_dense

    fn grid_auto_flow_column_dense() -> GridAutoFlow

    grid_auto_flow_row

    fn grid_auto_flow_row() -> GridAutoFlow

    grid_auto_flow_row_dense

    fn grid_auto_flow_row_dense() -> GridAutoFlow

    grid_max_content

    fn grid_max_content() -> Dimension

    grid_min_content

    fn grid_min_content() -> Dimension

    justify_content_center

    fn justify_content_center() -> AlignContent

    justify_content_end

    fn justify_content_end() -> AlignContent

    justify_content_flex_end

    fn justify_content_flex_end() -> AlignContent

    justify_content_flex_start

    fn justify_content_flex_start() -> AlignContent

    justify_content_space_around

    fn justify_content_space_around() -> AlignContent

    justify_content_space_between

    fn justify_content_space_between() -> AlignContent

    justify_content_space_evenly

    fn justify_content_space_evenly() -> AlignContent

    justify_content_start

    fn justify_content_start() -> AlignContent

    justify_content_stretch

    fn justify_content_stretch() -> AlignContent

    length

    fn length(value : Double) -> Dimension

    line

    fn line(value : Int) -> GridPlacement

    max_content

    fn max_content() -> AvailableSpace

    min_content

    fn min_content() -> AvailableSpace

    minmax

    fn minmax(min : Dimension, max : Dimension) -> Dimension

    overflow_clip

    fn overflow_clip() -> Overflow

    overflow_hidden

    fn overflow_hidden() -> Overflow

    overflow_scroll

    fn overflow_scroll() -> Overflow

    overflow_visible

    fn overflow_visible() -> Overflow

    percent

    fn percent(value : Double) -> Dimension

    place_auto

    fn place_auto() -> GridPlacement

    position_absolute

    fn position_absolute() -> Position

    position_relative

    fn position_relative() -> Position

    repeat

    fn repeat(repetition : GridTrackRepetition, tracks : Array[Dimension]) -> Dimension

    repeat_auto_fill

    fn repeat_auto_fill() -> GridTrackRepetition

    repeat_auto_fit

    fn repeat_auto_fit() -> GridTrackRepetition

    repeat_count

    fn repeat_count(count : Int) -> GridTrackRepetition

    span

    fn span(value : Int) -> GridPlacement

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io