🥮 mooncakes.io

moon_taffy

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

layout
flexbox
css
moon add Milky2018/moon_taffy@0.5.3
Download zip
Author
Version
0.5.3
License
Apache-2.0
Repository
Last updated
last month
Downloads
15K
README

#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

source
type NodeId = Int

#
TaffyError

source
type TaffyError

#
AlignContent

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

#
AlignItems

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

#
AvailableSpace

source
pub enum AvailableSpace {
  AvailDefinite(Double)
  AvailMinContent
  AvailMaxContent
}

#
Dimension

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

#
Display

source
pub enum Display {
  DisplayBlock
  DisplayFlex
  DisplayGrid
  DisplayNone
}

#
FlexDirection

source
pub enum FlexDirection {
  FlexRow
  FlexRowReverse
  FlexColumn
  FlexColumnReverse
}

#
FlexWrap

source
pub enum FlexWrap {
  FlexNoWrap
  FlexWrap
  FlexWrapReverse
}

#
GridAutoFlow

source
pub enum GridAutoFlow {
  Row
  Column
  RowDense
  ColumnDense
}

#
GridPlacement

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

#
GridTrackRepetition

source
pub enum GridTrackRepetition {
  RepeatCount(Int)
  RepeatAutoFill
  RepeatAutoFit
}

#
Layout

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

#
Layout::zero

source
fn Layout::zero() -> Layout

#
Line

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

#
Line::new

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

#
Node

source
type Node[C]

#
Overflow

source
pub enum Overflow {
  OverflowVisible
  OverflowClip
  OverflowHidden
  OverflowScroll
}

#
Point

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

#
Point::new

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

#
Point::zero

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

#
Position

source
pub enum Position {
  PosRelative
  PosAbsolute
}

#
Rect

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

#
Rect::new

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

#
Size

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

#
Size::max_content

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

#
Size::new

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

#
Size::zero

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

#
Style

source
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?
}

impl ToJson for Style
impl FromJson for Style

#
Style::default

source
fn Style::default() -> Style

#
Style::with_align_content

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

#
Style::with_align_items

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

#
Style::with_align_self

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

#
Style::with_aspect_ratio

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

#
Style::with_border

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

#
Style::with_display

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

#
Style::with_flex_basis

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

#
Style::with_flex_direction

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

#
Style::with_flex_grow

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

#
Style::with_flex_shrink

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

#
Style::with_flex_wrap

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

#
Style::with_gap

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

#
Style::with_grid_auto_columns

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

#
Style::with_grid_auto_flow

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

#
Style::with_grid_auto_rows

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

#
Style::with_grid_column

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

#
Style::with_grid_column_start

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

#
Style::with_grid_row

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

#
Style::with_grid_row_start

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

#
Style::with_grid_template_columns

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

#
Style::with_grid_template_rows

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

#
Style::with_inset

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

#
Style::with_justify_content

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

#
Style::with_justify_items

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

#
Style::with_justify_self

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

#
Style::with_margin

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

#
Style::with_max_size

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

#
Style::with_min_size

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

#
Style::with_overflow

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

#
Style::with_padding

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

#
Style::with_position

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

#
Style::with_scrollbar_width

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

#
Style::with_size

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

#
TaffyTree

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

#
TaffyTree::add_child

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

#
TaffyTree::clear_node_context

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

#
TaffyTree::compute_layout

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

#
TaffyTree::compute_layout_with_measure

source
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

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

#
TaffyTree::layout

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

#
TaffyTree::mark_dirty

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

#
TaffyTree::new

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

#
TaffyTree::new_leaf

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

#
TaffyTree::new_leaf_with_context

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

#
TaffyTree::new_with_children

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

#
TaffyTree::node_context

source
fn[C] TaffyTree::node_context(self : TaffyTree[C], node : Int) -> C? raise TaffyError

#
TaffyTree::remove

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

#
TaffyTree::remove_child

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

#
TaffyTree::remove_subtree

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

#
TaffyTree::set_children

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

#
TaffyTree::set_node_context

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

#
TaffyTree::set_style

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

#
TaffyTree::with_capacity

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

#
align_content_center

source
fn align_content_center() -> AlignContent

#
align_content_end

source
fn align_content_end() -> AlignContent

#
align_content_flex_end

source
fn align_content_flex_end() -> AlignContent

#
align_content_flex_start

source
fn align_content_flex_start() -> AlignContent

#
align_content_space_around

source
fn align_content_space_around() -> AlignContent

#
align_content_space_between

source
fn align_content_space_between() -> AlignContent

#
align_content_space_evenly

source
fn align_content_space_evenly() -> AlignContent

#
align_content_start

source
fn align_content_start() -> AlignContent

#
align_content_stretch

source
fn align_content_stretch() -> AlignContent

#
align_items_baseline

source
fn align_items_baseline() -> AlignItems

#
align_items_center

source
fn align_items_center() -> AlignItems

#
align_items_end

source
fn align_items_end() -> AlignItems

#
align_items_flex_end

source
fn align_items_flex_end() -> AlignItems

#
align_items_flex_start

source
fn align_items_flex_start() -> AlignItems

#
align_items_start

source
fn align_items_start() -> AlignItems

#
align_items_stretch

source
fn align_items_stretch() -> AlignItems

#
auto

source
fn auto() -> Dimension

#
available_space_definite

source
fn available_space_definite(value : Double) -> AvailableSpace

#
display_block

source
fn display_block() -> Display

#
display_flex

source
fn display_flex() -> Display

#
display_grid

source
fn display_grid() -> Display

#
display_none

source
fn display_none() -> Display

#
fit_content

source
fn fit_content(limit : Dimension) -> Dimension

#
flex_direction_column

source
fn flex_direction_column() -> FlexDirection

#
flex_direction_column_reverse

source
fn flex_direction_column_reverse() -> FlexDirection

#
flex_direction_row

source
fn flex_direction_row() -> FlexDirection

#
flex_direction_row_reverse

source
fn flex_direction_row_reverse() -> FlexDirection

#
flex_wrap_no_wrap

source
fn flex_wrap_no_wrap() -> FlexWrap

#
flex_wrap_wrap

source
fn flex_wrap_wrap() -> FlexWrap

#
flex_wrap_wrap_reverse

source
fn flex_wrap_wrap_reverse() -> FlexWrap

fn fr(value : Double) -> Dimension

#
grid_auto_flow_column

source
fn grid_auto_flow_column() -> GridAutoFlow

#
grid_auto_flow_column_dense

source
fn grid_auto_flow_column_dense() -> GridAutoFlow

#
grid_auto_flow_row

source
fn grid_auto_flow_row() -> GridAutoFlow

#
grid_auto_flow_row_dense

source
fn grid_auto_flow_row_dense() -> GridAutoFlow

#
grid_max_content

source
fn grid_max_content() -> Dimension

#
grid_min_content

source
fn grid_min_content() -> Dimension

#
justify_content_center

source
fn justify_content_center() -> AlignContent

#
justify_content_end

source
fn justify_content_end() -> AlignContent

#
justify_content_flex_end

source
fn justify_content_flex_end() -> AlignContent

#
justify_content_flex_start

source
fn justify_content_flex_start() -> AlignContent

#
justify_content_space_around

source
fn justify_content_space_around() -> AlignContent

#
justify_content_space_between

source
fn justify_content_space_between() -> AlignContent

#
justify_content_space_evenly

source
fn justify_content_space_evenly() -> AlignContent

#
justify_content_start

source
fn justify_content_start() -> AlignContent

#
justify_content_stretch

source
fn justify_content_stretch() -> AlignContent

#
length

source
fn length(value : Double) -> Dimension

#
line

source
fn line(value : Int) -> GridPlacement

#
max_content

source
fn max_content() -> AvailableSpace

#
min_content

source
fn min_content() -> AvailableSpace

#
minmax

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

#
overflow_clip

source
fn overflow_clip() -> Overflow

#
overflow_hidden

source
fn overflow_hidden() -> Overflow

#
overflow_scroll

source
fn overflow_scroll() -> Overflow

#
overflow_visible

source
fn overflow_visible() -> Overflow

#
percent

source
fn percent(value : Double) -> Dimension

#
place_auto

source
fn place_auto() -> GridPlacement

#
position_absolute

source
fn position_absolute() -> Position

#
position_relative

source
fn position_relative() -> Position

#
repeat

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

#
repeat_auto_fill

source
fn repeat_auto_fill() -> GridTrackRepetition

#
repeat_auto_fit

source
fn repeat_auto_fit() -> GridTrackRepetition

#
repeat_count

source
fn repeat_count(count : Int) -> GridTrackRepetition

#
span

source
fn span(value : Int) -> GridPlacement

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io