🥮 mooncakes.io
    Sign in

    #Flowchart values

    moonrockz/diagrams/flowchart provides immutable flowchart models without a syntax reader, renderer, host adapter or UI dependency. Mermaid flowcharts and both PlantUML activity dialects convert to this model. Callers can also construct it directly. Constructors copy caller-owned mutable collections.

    ///|
    test "construct an immutable flowchart with ordinary groups" {
      let nodes = [
        @flowchart.Node::new("Read", label="Read request", groups=["Work"]),
        @flowchart.Node::new("Save", label="Save", groups=["Work"]),
      ]
      let view = @flowchart.Flowchart::new(
        "request",
        nodes[:],
        [@flowchart.Connection::new("save", "Read", "Save")],
        direction=LR,
        groups=[@flowchart.Group::new("Work")],
        notes=[
          @flowchart.Note::new("Detail", "Source text", targets=["Read"], groups=[
            "Work",
          ]),
        ],
      )
      nodes[0] = @flowchart.Node::new("Changed")
      assert_eq(view.nodes[0].id, "Read")
      assert_eq(view.lanes.length(), 0)
      assert_eq(view.groups[0].id, "Work")
      assert_eq(view.connections[0].source, "Read")
      assert_eq(@flowchart.validate(view), [])
    }

    Nodes keep stable IDs, label kinds, vector shape identity, metadata, group paths, explicit lane ownership, typed roles, region membership and source bindings. Shape identity and control role are separate. A generic Mermaid diamond remains Generic; PlantUML conversion can supply Decision, Merge, Fork, Join, Start, ActivityFinal, FlowFinal, Connector or Action explicitly.

    Connections retain IDs, declared source/target, labels, line style, markers at both ends, length/direction hints, typed role and origin. Equal labels never merge separate occurrences. Global TB, BT, LR and RL affect placement without reversing stored endpoints. Source conversion accepts TD as TB.

    ///|
    test "control role and source identity are explicit values" {
      let origin = @flowchart.SourceBinding::new("caller", "actions/0")
      let action = @flowchart.Node::new("Review", role=Action, origin~)
      let view = @flowchart.Flowchart::new("review", [action], [])
      assert_eq(view.nodes[0].role, Action)
      assert_eq(view.nodes[0].origin.unwrap().path, "actions/0")
      assert_eq(view.nodes[0].origin.unwrap().span, None)
      assert_eq(@flowchart.validate(view), [])
      assert_true(!@flowchart.validate(view, work_limit=1).is_empty())
    }

    Groups retain their parent, label, optional local direction and expanded state. Ordinary subgraphs stay groups. Lanes represent explicit responsibility declarations and keep declared order. A PlantUML partition can span lane changes without changing a node's semantic group path. Notes retain node and connection attachments, text, placement and ownership. Note attachments are descriptive and never become control-flow route edges.

    Structured regions retain ordered branch and loop/parallel membership, conditions, entry/exit references and join specifications. These values describe source structure. The model never evaluates conditions, executes actions or implements token or synchronization semantics.

    validate uses explicit node, edge, depth and work limits. It reports duplicate identities, missing endpoints/note targets, ownership cycles, invalid group paths and inconsistent region references without repairing them. Source bindings use the shared half-open UTF-16 span contract when a source position exists. Construction, validation and transformations are deterministic on wasm, wasm-gc, js and native.

    Pass Diagram::Flowchart(view) to the shared SVG or animated renderer. Geometry, scene bindings, finite plans, structural routes and reachability are separate packages. See flowcharts and animation and run mise run test:flowchart-consumer for fresh model-only, native-reader and SVG/player consumers on all four targets.

    Branch

    source
    pub struct Branch {
      id : String
      label : String
      members : ReadOnlyArray[String]
      condition : String?
      origin : SourceBinding?
    } derive(Eq, 
    Debug    )

    Branch::equal

    source
    fn Branch::equal(Branch, Branch) -> Bool

    Branch::new

    source
    fn Branch::new(id : String, label? : String, members? : ArrayView[String], condition? : String, origin? : SourceBinding) -> Branch

    Branch::not_equal

    source
    fn Branch::not_equal(x : Branch, y : Branch) -> Bool

    Branch::to_repr

    source

    Connection

    source
    pub struct Connection {
      id : String
      source : String
      target : String
      label : String
      label_kind : LabelKind
      style : LineStyle
      source_marker : Marker
      target_marker : Marker
      min_length : Int
      direction : FlowDirection
      direction_hint : Direction?
      role : ConnectionRole
      origin : SourceBinding?
    } derive(Eq, 
    Debug    )

    Connection::equal

    source
    fn Connection::equal(Connection, Connection) -> Bool

    Connection::new

    source
    fn Connection::new(id : String, source : String, target : String, label? : String, label_kind? : LabelKind, style? : LineStyle, source_marker? : Marker, target_marker? : Marker, min_length? : Int, direction_hint? : Direction, role? : ConnectionRole, origin? : SourceBinding) -> Connection

    Connection::not_equal

    source
    fn Connection::not_equal(x : Connection, y : Connection) -> Bool

    Connection::to_repr

    source

    ConnectionRole

    source
    pub(all) enum ConnectionRole {
      Flow
      Branch
      LoopBack
      LoopExit
      Parallel
      NoteAttachment
      Layout
    } derive(Eq, 
    Debug    )

    ConnectionRole::equal

    source

    ConnectionRole::not_equal

    source
    fn ConnectionRole::not_equal(x : ConnectionRole, y : ConnectionRole) -> Bool

    ConnectionRole::to_repr

    source

    Direction

    source
    pub(all) enum Direction {
      TB
      BT
      LR
      RL
    } derive(Eq, 
    Debug    )

    Direction::equal

    source
    fn Direction::equal(Direction, Direction) -> Bool

    Direction::not_equal

    source
    fn Direction::not_equal(x : Direction, y : Direction) -> Bool

    Direction::to_repr

    source

    FlowDirection

    source
    pub(all) enum FlowDirection {
      Forward
      Backward
      Both
      Undirected
      Invisible
    } derive(Eq, 
    Debug    )

    FlowDirection::equal

    source

    FlowDirection::not_equal

    source
    fn FlowDirection::not_equal(x : FlowDirection, y : FlowDirection) -> Bool

    FlowDirection::to_repr

    source

    Flowchart

    source
    pub struct Flowchart {
      notes : ReadOnlyArray[Note]
      regions : ReadOnlyArray[Region]
      id : String
      direction : Direction
      lanes : ReadOnlyArray[Lane]
      groups : ReadOnlyArray[Group]
      nodes : ReadOnlyArray[Node]
      connections : ReadOnlyArray[Connection]
      title : String?
      accessibility_title : String?
      accessibility_description : String?
    } derive(Eq, 
    Debug    )

    Flowchart::equal

    source
    fn Flowchart::equal(Flowchart, Flowchart) -> Bool

    Flowchart::new

    source
    fn Flowchart::new(id : String, nodes : ArrayView[Node], connections : ArrayView[Connection], direction? : Direction, lanes? : ArrayView[Lane], groups? : ArrayView[Group], title? : String, accessibility_title? : String, accessibility_description? : String, notes? : ArrayView[Note], regions? : ArrayView[Region]) -> Flowchart

    Flowchart::not_equal

    source
    fn Flowchart::not_equal(x : Flowchart, y : Flowchart) -> Bool

    Flowchart::to_repr

    source

    Flowchart::with_nodes

    source
    fn Flowchart::with_nodes(self : Flowchart, nodes : ArrayView[Node]) -> Flowchart

    Replace the ordered nodes, copying the caller's collection.

    Group

    source
    pub struct Group {
      id : String
      label : String
      parent : String?
      lane : String?
      direction : Direction?
      expanded : Bool
    } derive(Eq, 
    Debug    )

    Group::equal

    source
    fn Group::equal(Group, Group) -> Bool

    Group::new

    source
    fn Group::new(id : String, label? : String, parent? : String, lane? : String, direction? : Direction, expanded? : Bool) -> Group

    Group::not_equal

    source
    fn Group::not_equal(x : Group, y : Group) -> Bool

    Group::to_repr

    source

    LabelKind

    source
    pub(all) enum LabelKind {
      Text
      Markdown
      Html
    } derive(Eq, 
    Debug    )

    LabelKind::equal

    source
    fn LabelKind::equal(LabelKind, LabelKind) -> Bool

    LabelKind::not_equal

    source
    fn LabelKind::not_equal(x : LabelKind, y : LabelKind) -> Bool

    LabelKind::to_repr

    source

    Lane

    source
    pub struct Lane {
      id : String
      label : String
      direction : Direction?
      expanded : Bool
    } derive(Eq, 
    Debug    )

    Lane::equal

    source
    fn Lane::equal(Lane, Lane) -> Bool

    Lane::new

    source
    fn Lane::new(id : String, label? : String, direction? : Direction, expanded? : Bool) -> Lane

    Lane::not_equal

    source
    fn Lane::not_equal(x : Lane, y : Lane) -> Bool

    Lane::to_repr

    source

    LineStyle

    source
    pub(all) enum LineStyle {
      Solid
      Dotted
      Thick
      Invisible
    } derive(Eq, 
    Debug    )

    LineStyle::equal

    source
    fn LineStyle::equal(LineStyle, LineStyle) -> Bool

    LineStyle::not_equal

    source
    fn LineStyle::not_equal(x : LineStyle, y : LineStyle) -> Bool

    LineStyle::to_repr

    source

    Marker

    source
    pub(all) enum Marker {
      None
      Arrow
      Circle
      Cross
    } derive(Eq, 
    Debug    )

    Marker::equal

    source
    fn Marker::equal(Marker, Marker) -> Bool

    Marker::not_equal

    source
    fn Marker::not_equal(x : Marker, y : Marker) -> Bool

    Marker::to_repr

    source

    Node

    source
    pub struct Node {
      id : String
      label : String
      label_kind : LabelKind
      shape : String
      metadata : ReadOnlyArray[(String, String)]
      lane : String?
      groups : ReadOnlyArray[String]
      properties : RenderProperties?
      role : Role
      regions : ReadOnlyArray[String]
      origin : SourceBinding?
    } derive(Eq, 
    Debug    )

    Node::equal

    source
    fn Node::equal(Node, Node) -> Bool

    Node::new

    source
    fn Node::new(id : String, label? : String, label_kind? : LabelKind, shape? : String, metadata? : ArrayView[(String, String)], lane? : String, groups? : ArrayView[String], properties? : RenderProperties, role? : Role, regions? : ArrayView[String], origin? : SourceBinding) -> Node

    Node::not_equal

    source
    fn Node::not_equal(x : Node, y : Node) -> Bool

    Node::to_repr

    source

    Node::with_label

    source
    fn Node::with_label(self : Node, label : String) -> Node

    Replace a label while preserving identity, control role and source binding.

    Note

    source
    pub struct Note {
      id : String
      text : String
      targets : ReadOnlyArray[String]
      connection_targets : ReadOnlyArray[String]
      placement : String
      groups : ReadOnlyArray[String]
      lane : String?
      origin : SourceBinding?
    } derive(Eq, 
    Debug    )

    Note::equal

    source
    fn Note::equal(Note, Note) -> Bool

    Note::new

    source
    fn Note::new(id : String, text : String, targets? : ArrayView[String], connection_targets? : ArrayView[String], placement? : String, groups? : ArrayView[String], lane? : String, origin? : SourceBinding) -> Note

    Note::not_equal

    source
    fn Note::not_equal(x : Note, y : Note) -> Bool

    Note::to_repr

    source

    Region

    source
    pub struct Region {
      id : String
      kind : RegionKind
      parent : String?
      entry : String?
      exit : String?
      members : ReadOnlyArray[String]
      branches : ReadOnlyArray[Branch]
      condition : String?
      join_specification : String?
      origin : SourceBinding?
    } derive(Eq, 
    Debug    )

    Region::equal

    source
    fn Region::equal(Region, Region) -> Bool

    Region::new

    source
    fn Region::new(id : String, kind : RegionKind, parent? : String, entry? : String, exit? : String, members? : ArrayView[String], branches? : ArrayView[Branch], condition? : String, join_specification? : String, origin? : SourceBinding) -> Region

    Region::not_equal

    source
    fn Region::not_equal(x : Region, y : Region) -> Bool

    Region::to_repr

    source

    RegionKind

    source
    pub(all) enum RegionKind {
      Conditional
      Loop
      Parallel
      Split
    } derive(Eq, 
    Debug    )

    RegionKind::equal

    source
    fn RegionKind::equal(RegionKind, RegionKind) -> Bool

    RegionKind::not_equal

    source
    fn RegionKind::not_equal(x : RegionKind, y : RegionKind) -> Bool

    RegionKind::to_repr

    source

    RenderProperties

    source
    pub struct RenderProperties {
      link : String?
      metadata : ReadOnlyArray[(String, String)]
    } derive(Eq, 
    Debug    )

    RenderProperties::equal

    source

    RenderProperties::new

    source
    fn RenderProperties::new(link? : String, metadata? : ArrayView[(String, String)]) -> RenderProperties

    RenderProperties::not_equal

    source
    fn RenderProperties::not_equal(x : RenderProperties, y : RenderProperties) -> Bool

    RenderProperties::to_repr

    source

    Role

    source
    pub(all) enum Role {
      Generic
      Action
      Decision
      Merge
      Fork
      Join
      Start
      ActivityFinal
      FlowFinal
      Connector
    } derive(Eq, 
    Debug    )

    Role::equal

    source
    fn Role::equal(Role, Role) -> Bool

    Role::not_equal

    source
    fn Role::not_equal(x : Role, y : Role) -> Bool

    Role::to_repr

    source

    SourceBinding

    source
    pub struct SourceBinding {
      format : String
      path : String
      span : 
    Span    ?
    } derive(Eq, 
    Debug    )

    Explicit source binding; positions use the library UTF-16 span contract.

    SourceBinding::equal

    source

    SourceBinding::new

    source
    fn SourceBinding::new(format : String, path : String, span? : 
    Span    ) -> SourceBinding

    SourceBinding::not_equal

    source
    fn SourceBinding::not_equal(x : SourceBinding, y : SourceBinding) -> Bool

    SourceBinding::to_repr

    source

    built_in_shapes

    source
    let built_in_shapes : ReadOnlyArray[String]

    canonical_shape

    source
    fn canonical_shape(value : String) -> String

    diagnostic_codes

    source
    let diagnostic_codes : ReadOnlyArray[String]

    direction

    source
    fn direction(value : String) -> Direction?

    fresh_id

    source
    fn fresh_id(stem : String, used : ArrayView[String], work_limit? : Int) -> Result[String, 
    Diagnostic    ]

    Allocate a deterministic identity without colliding with authored identities.

    validate

    source
    fn validate(model : Flowchart, nodes_limit? : Int, edges_limit? : Int, depth_limit? : Int, work_limit? : Int) -> ReadOnlyArray[
    Diagnostic    ]

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io