🥮 mooncakes.io

moon_dagre

Dagre layout engine implemented in MoonBit

layout
moon add Milky2018/moon_dagre@0.2.5
Download zip
Author
Version
0.2.5
License
Apache-2.0
Repository
Last updated
4 months ago
Downloads
1K
README

#Milky2018/moon_dagre

A MoonBit port of the dagre graph layout engine.

Repository: https://github.com/moonbit-community/moon_dagre

#Install

moon add Milky2018/moon_dagre

#Basic Usage

moon.pkg:
import {
  "Milky2018/moon_dagre" @dagre,
}

main.mbt:
///|
fn main {
  let g = dagre.new_graph(directed=true, multigraph=true, compound=true)
  g.set_node(
    "a",
    label=dagre
      .empty_attrs()
      .tap(n => {
        n.set_float("width", 80.0)
        n.set_float("height", 40.0)
      }),
  )
  g.set_node(
    "b",
    label=dagre
      .empty_attrs()
      .tap(n => {
        n.set_float("width", 80.0)
        n.set_float("height", 40.0)
      }),
  )
  g.set_edge("a", "b", label=dagre.attrs_value(dagre.empty_attrs()))

  dagre.layout(g)

  // Read computed coordinates from node labels:
  // g.node("a").get_float("x"), g.node("a").get_float("y"), ...
}

#API

  • Entry points:
    • dagre.new_graph(...)
    • dagre.layout(g)
  • Version:
    • dagre.version()

For full exported symbols, check pkg.generated.mbti.

#
Attr

source
pub enum Attr {
  Bool(Bool)
  Int(Int)
  Float(Double)
  String(String)
  Val(Value)
  Point(Point)
  Points(Array[Point])
  Edge(EdgeObj)
  Edges(Array[EdgeObj])
  Strings(Array[String])
  Ints(Array[Int])
}

#
Attrs

source
pub struct Attrs {
  map : Map[String, Attr]
}

#
Attrs::contains

source
fn Attrs::contains(self : Attrs, key : String) -> Bool

#
Attrs::get

source
fn Attrs::get(self : Attrs, key : String) -> Attr?

#
Attrs::get_bool

source
fn Attrs::get_bool(self : Attrs, key : String) -> Bool?

#
Attrs::get_bool_or

source
fn Attrs::get_bool_or(self : Attrs, key : String, fallback : Bool) -> Bool

#
Attrs::get_edge

source
fn Attrs::get_edge(self : Attrs, key : String) -> EdgeObj?

#
Attrs::get_edges

source
fn Attrs::get_edges(self : Attrs, key : String) -> Array[EdgeObj]?

#
Attrs::get_float

source
fn Attrs::get_float(self : Attrs, key : String) -> Double?

#
Attrs::get_float_or

source
fn Attrs::get_float_or(self : Attrs, key : String, fallback : Double) -> Double

#
Attrs::get_int

source
fn Attrs::get_int(self : Attrs, key : String) -> Int?

#
Attrs::get_int_or

source
fn Attrs::get_int_or(self : Attrs, key : String, fallback : Int) -> Int

#
Attrs::get_ints

source
fn Attrs::get_ints(self : Attrs, key : String) -> Array[Int]?

#
Attrs::get_point

source
fn Attrs::get_point(self : Attrs, key : String) -> Point?

#
Attrs::get_points

source
fn Attrs::get_points(self : Attrs, key : String) -> Array[Point]?

#
Attrs::get_string

source
fn Attrs::get_string(self : Attrs, key : String) -> String?

#
Attrs::get_string_or

source
fn Attrs::get_string_or(self : Attrs, key : String, fallback : String) -> String

#
Attrs::get_strings

source
fn Attrs::get_strings(self : Attrs, key : String) -> Array[String]?

#
Attrs::get_value

source
fn Attrs::get_value(self : Attrs, key : String) -> Value?

#
Attrs::keys

source
fn Attrs::keys(self : Attrs) -> Array[String]

#
Attrs::length

source
fn Attrs::length(self : Attrs) -> Int

#
Attrs::remove

source
fn Attrs::remove(self : Attrs, key : String) -> Unit

#
Attrs::set

source
fn Attrs::set(self : Attrs, key : String, value : Attr) -> Unit

#
Attrs::set_bool

source
fn Attrs::set_bool(self : Attrs, key : String, value : Bool) -> Unit

#
Attrs::set_edge

source
fn Attrs::set_edge(self : Attrs, key : String, value : EdgeObj) -> Unit

#
Attrs::set_edges

source
fn Attrs::set_edges(self : Attrs, key : String, value : Array[EdgeObj]) -> Unit

#
Attrs::set_float

source
fn Attrs::set_float(self : Attrs, key : String, value : Double) -> Unit

#
Attrs::set_int

source
fn Attrs::set_int(self : Attrs, key : String, value : Int) -> Unit

#
Attrs::set_ints

source
fn Attrs::set_ints(self : Attrs, key : String, value : Array[Int]) -> Unit

#
Attrs::set_point

source
fn Attrs::set_point(self : Attrs, key : String, value : Point) -> Unit

#
Attrs::set_points

source
fn Attrs::set_points(self : Attrs, key : String, value : Array[Point]) -> Unit

#
Attrs::set_string

source
fn Attrs::set_string(self : Attrs, key : String, value : String) -> Unit

#
Attrs::set_strings

source
fn Attrs::set_strings(self : Attrs, key : String, value : Array[String]) -> Unit

#
Attrs::set_value

source
fn Attrs::set_value(self : Attrs, key : String, value : Value) -> Unit

#
EdgeObj

source
pub struct EdgeObj {
  v : String
  w : String
  name : String?
}

#
EdgeRecord

source
type EdgeRecord

#
Graph

source
pub struct Graph {
  directed : Bool
  multigraph : Bool
  compound : Bool
  graph_label : Attrs
  nodes : Map[String, Attrs]
  node_order : Array[String]
  node_index : Map[String, Int]
  node_seen : 
Set[String]
  edges : Map[String, EdgeRecord]
  edge_order : Array[String]
  edge_seen : 
Set[String]
  parent_by_node : Map[String, String]
  children_by_node : Map[String, 
Set[String]]
  child_seq : Int
  child_add_index : Map[String, Int]
  default_edge_label_fn : () -> Value

  fn new(directed? : Bool, multigraph? : Bool, compound? : Bool) -> Graph
}

#
Graph::children

source
fn Graph::children(self : Graph, v? : String) -> Array[String]

#
Graph::edge

source
fn Graph::edge(self : Graph, v : String, w : String, name? : String) -> Value?

#
Graph::edge_count

source
fn Graph::edge_count(self : Graph) -> Int

#
Graph::edge_obj

source
fn Graph::edge_obj(self : Graph, e : EdgeObj) -> Value?

#
Graph::edges

source
fn Graph::edges(self : Graph) -> Array[EdgeObj]

#
Graph::graph

source
fn Graph::graph(self : Graph) -> Attrs

#
Graph::has_edge

source
fn Graph::has_edge(self : Graph, v : String, w : String, name? : String) -> Bool

#
Graph::has_node

source
fn Graph::has_node(self : Graph, v : String) -> Bool

#
Graph::in_edges

source
fn Graph::in_edges(self : Graph, v : String, u? : String) -> Array[EdgeObj]

#
Graph::is_compound

source
fn Graph::is_compound(self : Graph) -> Bool

#
Graph::is_directed

source
fn Graph::is_directed(self : Graph) -> Bool

#
Graph::is_multigraph

source
fn Graph::is_multigraph(self : Graph) -> Bool

#
Graph::neighbors

source
fn Graph::neighbors(self : Graph, v : String) -> Array[String]

#
Graph::new

source
fn Graph::new(directed? : Bool, multigraph? : Bool, compound? : Bool) -> Graph

#
Graph::node

source
fn Graph::node(self : Graph, v : String) -> Attrs

#
Graph::node_count

source
fn Graph::node_count(self : Graph) -> Int

#
Graph::node_edges

source
fn Graph::node_edges(self : Graph, v : String, w? : String) -> Array[EdgeObj]

#
Graph::node_opt

source
fn Graph::node_opt(self : Graph, v : String) -> Attrs?

#
Graph::nodes

source
fn Graph::nodes(self : Graph) -> Array[String]

#
Graph::out_edges

source
fn Graph::out_edges(self : Graph, v : String, w? : String) -> Array[EdgeObj]

#
Graph::parent

source
fn Graph::parent(self : Graph, v : String) -> String?

#
Graph::predecessors

source
fn Graph::predecessors(self : Graph, v : String) -> Array[String]

#
Graph::remove_edge

source
fn Graph::remove_edge(self : Graph, v : String, w : String, name? : String) -> Unit

#
Graph::remove_edge_obj

source
fn Graph::remove_edge_obj(self : Graph, e : EdgeObj) -> Unit

#
Graph::remove_node

source
fn Graph::remove_node(self : Graph, v : String) -> Unit

#
Graph::set_default_edge_label

source
fn Graph::set_default_edge_label(self : Graph, f : () -> Value) -> Unit

#
Graph::set_edge

source
fn Graph::set_edge(self : Graph, v : String, w : String, label? : Value, name? : String) -> Unit

#
Graph::set_edge_obj

source
fn Graph::set_edge_obj(self : Graph, e : EdgeObj, label? : Value) -> Unit

#
Graph::set_graph

source
fn Graph::set_graph(self : Graph, label : Attrs) -> Unit

#
Graph::set_node

source
fn Graph::set_node(self : Graph, v : String, label? : Attrs) -> Unit

#
Graph::set_nodes

source
fn Graph::set_nodes(self : Graph, vs : Array[String], label? : Attrs) -> Unit

#
Graph::set_parent

source
fn Graph::set_parent(self : Graph, v : String, parent? : String) -> Unit

#
Graph::set_path

source
fn Graph::set_path(self : Graph, vs : Array[String], label? : Value) -> Unit

#
Graph::sinks

source
fn Graph::sinks(self : Graph) -> Array[String]

#
Graph::sources

source
fn Graph::sources(self : Graph) -> Array[String]

#
Graph::successors

source
fn Graph::successors(self : Graph, v : String) -> Array[String]

#
OrderBarycenterEntry

source
pub struct OrderBarycenterEntry {
  v : String
  barycenter : Double?
  weight : Double?
}

#
OrderEntry

source
pub struct OrderEntry {
  vs : Array[String]
  i : Int
  barycenter : Double?
  weight : Double?
}

#
OrderResult

source
pub struct OrderResult {
  vs : Array[String]
  barycenter : Double?
  weight : Double?
}

#
Partition

source
pub struct Partition[T] {
  lhs : Array[T]
  rhs : Array[T]
}

#
Point

source
pub struct Point {
  x : Double
  y : Double
}

#
PositionBkAlignment

source
pub struct PositionBkAlignment {
  root : Map[String, String]
  align : Map[String, String]
}

#
Rect

source
pub struct Rect {
  x : Double
  y : Double
  width : Double
  height : Double
}

#
Value

source
pub enum Value {
  VNull
  VBool(Bool)
  VInt(Int)
  VFloat(Double)
  VString(String)
  VAttrs(Attrs)
}

#
acyclic_run

source
fn acyclic_run(g : Graph) -> Unit

#
acyclic_undo

source
fn acyclic_undo(g : Graph) -> Unit

#
add_border_node

source
fn add_border_node(g : Graph, prefix : String, rank? : Int, order? : Int) -> String

#
add_border_segments

source
fn add_border_segments(g : Graph) -> Unit

#
add_dummy_node

source
fn add_dummy_node(g : Graph, typ : String, attrs : Attrs, name : String) -> String

#
apply_with_chunking_max

source
fn apply_with_chunking_max(values : Array[Int]) -> Int

#
apply_with_chunking_min

source
fn apply_with_chunking_min(values : Array[Int]) -> Int

#
as_non_compound_graph

source
fn as_non_compound_graph(g : Graph) -> Graph

#
attrs_value

source
fn attrs_value(attrs : Attrs) -> Value

#
build_layer_matrix

source
fn build_layer_matrix(g : Graph) -> Array[Array[String]]

#
clone_attrs

source
fn clone_attrs(attrs : Attrs) -> Attrs

#
clone_value

source
fn clone_value(value : Value) -> Value

#
components

source
fn components(g : Graph) -> Array[Array[String]]

#
coordinate_adjust

source
fn coordinate_adjust(g : Graph) -> Unit

#
coordinate_undo

source
fn coordinate_undo(g : Graph) -> Unit

#
edge_obj

source
fn edge_obj(v : String, w : String, name? : String) -> EdgeObj

#
empty_attrs

source
fn empty_attrs() -> Attrs

#
find_cycles

source
fn find_cycles(g : Graph) -> Array[Array[String]]

#
greedy_fas

source
fn greedy_fas(g : Graph, weight_fn? : (EdgeObj) -> Double) -> Array[EdgeObj]

#
intersect_rect

source
fn intersect_rect(rect : Rect, pt : Point) -> Point

#
layout

source
fn layout(g : Graph, debug_timing? : Bool) -> Graph

#
layout_layout_graph_debug

source
fn layout_layout_graph_debug(input_graph : Graph, stop_before_remove_border_nodes? : Bool, stop_after_rank? : Bool, stop_after_order? : Bool, stop_after_normalize_undo? : Bool, stop_after_coordinate_undo? : Bool, stop_after_translate_graph? : Bool) -> Graph

#
layout_run

source
fn layout_run(g : Graph, debug_timing? : Bool) -> Graph

#
map_values

source
fn[V, U] map_values(obj : Map[String, V], f : (V, String) -> U) -> Map[String, U]

#
map_values_prop

source
fn map_values_prop(obj : Map[String, Attrs], prop : String) -> Map[String, Attr]

#
max_rank

source
fn max_rank(g : Graph) -> Int

#
nesting_graph_cleanup

source
fn nesting_graph_cleanup(g : Graph) -> Unit

#
nesting_graph_run

source
fn nesting_graph_run(g : Graph) -> Unit

#
new_graph

source
fn new_graph(directed? : Bool, multigraph? : Bool, compound? : Bool) -> Graph

#
normalize_ranks

source
fn normalize_ranks(g : Graph) -> Unit

#
normalize_run

source
fn normalize_run(g : Graph) -> Unit

#
normalize_undo

source
fn normalize_undo(g : Graph) -> Unit

#
notime

source
fn[T] notime(name : String, thunk : () -> T) -> T

#
order_add_subgraph_constraints

source
fn order_add_subgraph_constraints(g : Graph, cg : Graph, vs : Array[String]) -> Unit

#
order_bary_entry

source
fn order_bary_entry(v : String, barycenter? : Double?, weight? : Double?) -> OrderBarycenterEntry

#
order_barycenter

source
fn order_barycenter(g : Graph, movable? : Array[String]) -> Array[OrderBarycenterEntry]

#
order_build_layer_graph

source
fn order_build_layer_graph(g : Graph, rank : Int, relationship : String) -> Graph

#
order_cross_count

source
fn order_cross_count(g : Graph, layering : Array[Array[String]]) -> Double

#
order_entry

source
fn order_entry(vs : Array[String], i : Int, barycenter? : Double?, weight? : Double?) -> OrderEntry

#
order_init_order

source
fn order_init_order(g : Graph) -> Array[Array[String]]

#
order_resolve_conflicts

source
fn order_resolve_conflicts(entries : Array[OrderBarycenterEntry], cg : Graph) -> Array[OrderEntry]

#
order_result

source
fn order_result(vs : Array[String], barycenter? : Double?, weight? : Double?) -> OrderResult

#
order_run

source
fn order_run(g : Graph) -> Unit

#
order_sort

source
fn order_sort(entries : Array[OrderEntry], bias_right? : Bool) -> OrderResult

#
order_sort_subgraph

source
fn order_sort_subgraph(g : Graph, v : String, cg : Graph, bias_right? : Bool) -> OrderResult

#
parent_dummy_chains

source
fn parent_dummy_chains(g : Graph) -> Unit

#
partition

source
fn[T] partition(collection : Array[T], predicate : (T) -> Bool) -> Partition[T]

#
pick

source
fn pick(source : Attrs, keys : Array[String]) -> Attrs

#
point

source
fn point(x : Double, y : Double) -> Point

#
position

source
fn position(g : Graph) -> Unit

#
position_bk_add_conflict

source
fn position_bk_add_conflict(conflicts : Map[String, 
Set[String]], v : String, w : String) -> Unit

#
position_bk_align_coordinates

source
fn position_bk_align_coordinates(xss : Map[String, Map[String, Double]], align_to : Map[String, Double]) -> Unit

#
position_bk_balance

source
fn position_bk_balance(xss : Map[String, Map[String, Double]], align? : String) -> Map[String, Double]

#
position_bk_find_smallest_width_alignment

source
fn position_bk_find_smallest_width_alignment(g : Graph, xss : Map[String, Map[String, Double]]) -> Map[String, Double]

#
position_bk_find_type1_conflicts

source
fn position_bk_find_type1_conflicts(g : Graph, layering : Array[Array[String]]) -> Map[String, 
Set[String]]

#
position_bk_find_type2_conflicts

source
fn position_bk_find_type2_conflicts(g : Graph, layering : Array[Array[String]]) -> Map[String, 
Set[String]]

#
position_bk_has_conflict

source
fn position_bk_has_conflict(conflicts : Map[String, 
Set[String]], v : String, w : String) -> Bool

#
position_bk_horizontal_compaction

source
fn position_bk_horizontal_compaction(g : Graph, layering : Array[Array[String]], root : Map[String, String], align : Map[String, String], reverse_sep? : Bool) -> Map[String, Double]

#
position_bk_vertical_alignment

source
fn position_bk_vertical_alignment(g : Graph, layering : Array[Array[String]], conflicts : Map[String, 
Set[String]], neighbor_fn : (String) -> Array[String]) -> PositionBkAlignment

#
position_bk_x

source
fn position_bk_x(g : Graph) -> Map[String, Double]

#
position_x

source
fn position_x(g : Graph) -> Map[String, Double]

#
position_y

source
fn position_y(g : Graph) -> Unit

#
postorder

source
fn postorder(g : Graph, roots : Array[String]) -> Array[String]

#
predecessor_weights

source
fn predecessor_weights(g : Graph) -> Map[String, Map[String, Double]]

#
preorder

source
fn preorder(g : Graph, roots : Array[String]) -> Array[String]

#
range

source
fn range(start : Int, limit? : Int, step? : Int) -> Array[Int]

#
rank

source
fn rank(g : Graph) -> Unit

#
rank_feasible_tree

source
fn rank_feasible_tree(g : Graph) -> Graph

#
rank_longest_path

source
fn rank_longest_path(g : Graph) -> Unit

#
rank_network_simplex

source
fn rank_network_simplex(g : Graph) -> Unit

#
rank_network_simplex_calc_cut_value

source
fn rank_network_simplex_calc_cut_value(t : Graph, g : Graph, child : String) -> Int

#
rank_network_simplex_enter_edge

source
fn rank_network_simplex_enter_edge(t : Graph, g : Graph, edge : EdgeObj) -> EdgeObj

#
rank_network_simplex_exchange_edges

source
fn rank_network_simplex_exchange_edges(t : Graph, g : Graph, leaving_edge : EdgeObj, entering_edge : EdgeObj) -> Unit

#
rank_network_simplex_init_cut_values

source
fn rank_network_simplex_init_cut_values(t : Graph, g : Graph) -> Unit

#
rank_network_simplex_init_low_lim_values

source
fn rank_network_simplex_init_low_lim_values(tree : Graph, root? : String) -> Unit

#
rank_network_simplex_leave_edge

source
fn rank_network_simplex_leave_edge(tree : Graph) -> EdgeObj?

#
rank_slack

source
fn rank_slack(g : Graph, e : EdgeObj) -> Int

#
rect

source
fn rect(x : Double, y : Double, width : Double, height : Double) -> Rect

#
remove_empty_ranks

source
fn remove_empty_ranks(g : Graph) -> Unit

#
simplify

source
fn simplify(g : Graph) -> Graph

#
successor_weights

source
fn successor_weights(g : Graph) -> Map[String, Map[String, Double]]

#
time

source
fn[T] time(name : String, thunk : () -> T) -> T

#
value_as_attrs

source
fn value_as_attrs(value : Value?) -> Attrs?

#
value_as_bool

source
fn value_as_bool(value : Value?) -> Bool?

#
value_as_float

source
fn value_as_float(value : Value?) -> Double?

#
value_as_int

source
fn value_as_int(value : Value?) -> Int?

#
value_as_string

source
fn value_as_string(value : Value?) -> String?

#
value_bool

source
fn value_bool(v : Bool) -> Value

#
value_float

source
fn value_float(v : Double) -> Value

#
value_int

source
fn value_int(v : Int) -> Value

#
value_null

source
fn value_null() -> Value

#
value_string

source
fn value_string(v : String) -> Value

#
version

source
fn version() -> String

#
zip_object

source
fn[T] zip_object(props : Array[String], values : Array[T]) -> Map[String, T]

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io