`moonrockz/diagrams/animation`

Types

`Active`

pub struct Active {
  ordinal : Int
  key : String
  numerator : Int64
  denominator : Int64
  concurrent_groups : ReadOnlyArray[Int]
  reversed : Bool
  visit : Bool
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Active::equal`

fn Active::equal(Active, Active) -> Bool

Source

`Active::not_equal`

fn Active::not_equal(x : Active, y : Active) -> Bool

Source

`Active::to_repr`

fn Active::to_repr(Active) -> @moonbitlang/core/debug.Repr

Source

`Catalog`

pub struct Catalog {
  view_id : String
  source : @moonrockz/diagrams/render.Diagram
  occurrences : ReadOnlyArray[Occurrence]
  frames : ReadOnlyArray[FrameInfo]
  controls : ReadOnlyArray[Control]
  graph : Graph
  // private fields
}

Source

`Catalog::architecture`

fn Catalog::architecture(view : @moonrockz/diagrams/architecture.Architecture, limits? : Limits) -> CatalogResult

Authored architecture connections define the graph. Groups and alignments add no edges.

Source

`Catalog::bpmn`

fn Catalog::bpmn(view : @moonrockz/diagrams/bpmn.Bpmn, limits? : Limits) -> CatalogResult

Source

`Catalog::connection`

fn Catalog::connection(self : Catalog, id : String) -> Occurrence?

Source

`Catalog::data_tree`

fn Catalog::data_tree(tree : @moonrockz/diagrams/data-tree.DataTree, limits? : Limits) -> CatalogResult

A catalog of a data tree. Every box and member row is a visit target. A connector exists only from a row to a nested container box. The graph has containment edges between values and no other relation.

Source

`Catalog::ebnf`

fn Catalog::ebnf(grammar : @moonrockz/diagrams/ebnf.Grammar, limits? : Limits) -> CatalogResult

A catalog of a grammar railroad. References are inspectable visit targets; they never add an edge to another rule.

Source

`Catalog::flow`

fn Catalog::flow(self : Catalog, id : String) -> Occurrence?

Source

`Catalog::flowchart`

fn Catalog::flowchart(view : @moonrockz/diagrams/flowchart.Flowchart, limits? : Limits) -> CatalogResult

Flowchart paths are structural connections. Containment never adds an arc.

Source

`Catalog::motion`

fn Catalog::motion(self : Catalog, key : String, duration_ms : Int64, reversed : Bool) -> Motion

The motion for one occurrence: a visit for a node target, or a connection step with the given orientation.

Source

`Catalog::occurrence`

fn Catalog::occurrence(self : Catalog, key : String) -> Occurrence?

Source

`Catalog::reference_target`

fn Catalog::reference_target(self : Catalog, key : String) -> String?

The rule identity that an EBNF reference term resolves to. A reference is an inspectable target; no route edge joins the two rules.

Source

`Catalog::regex`

fn Catalog::regex(model : @moonrockz/diagrams/regex.Regex, limits? : Limits) -> CatalogResult

A catalog of a regex railroad: terms are visits, connectors are paths.

Source

`Catalog::sequence`

fn Catalog::sequence(sequence : @moonrockz/diagrams/sequence.Sequence, view_id? : String, limits? : Limits) -> CatalogResult

Message vertices are occurrences, not participants. Frame branches remain explicit; a loop contributes one authored structural iteration, never a participant cycle or an inferred unbounded execution.

Source

`Catalog::state`

fn Catalog::state(view : @moonrockz/diagrams/state.StateDiagram, limits? : Limits) -> CatalogResult

A structural state catalog. Ownership, history and descriptions add no arcs.

Source

`Catalog::swimlane`

fn Catalog::swimlane(view : @moonrockz/diagrams/swimlane.Swimlane, limits? : Limits) -> CatalogResult

Swimlane paths are structural connections. Containment never adds an arc.

Source

`CatalogResult`

pub struct CatalogResult {
  catalog : Catalog?
  diagnostics : ReadOnlyArray[@moonrockz/diagrams.Diagnostic]
}

Source

`Choice`

pub(all) enum Choice {
  Alternative(Int)
  Repetitions(Int)
  Optional(Bool)
  ExceptionSections(ReadOnlyArray[Int])
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Choice::equal`

fn Choice::equal(Choice, Choice) -> Bool

Source

`Choice::not_equal`

fn Choice::not_equal(x : Choice, y : Choice) -> Bool

Source

`Choice::to_repr`

fn Choice::to_repr(Choice) -> @moonbitlang/core/debug.Repr

Source

`Control`

pub(all) enum Control {
  Message(Int)
  Frame(Int)
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Control::equal`

fn Control::equal(Control, Control) -> Bool

Source

`Control::not_equal`

fn Control::not_equal(x : Control, y : Control) -> Bool

Source

`Control::to_repr`

fn Control::to_repr(Control) -> @moonbitlang/core/debug.Repr

Source

`Direction`

pub(all) enum Direction {
  Forward
  Reverse
  Both
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Direction::equal`

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

Source

`Direction::not_equal`

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

Source

`Direction::to_repr`

fn Direction::to_repr(Direction) -> @moonbitlang/core/debug.Repr

Source

`EdgeKind`

pub(all) enum EdgeKind {
  SequenceFlow
  MessageFlow
  Order
  SwimlaneFlow
  StateTransition
  FlowchartFlow
  ArchitectureFlow
  Undirected
  Railroad
  Containment
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`EdgeKind::equal`

fn EdgeKind::equal(EdgeKind, EdgeKind) -> Bool

Source

`EdgeKind::not_equal`

fn EdgeKind::not_equal(x : EdgeKind, y : EdgeKind) -> Bool

Source

`EdgeKind::to_repr`

fn EdgeKind::to_repr(EdgeKind) -> @moonbitlang/core/debug.Repr

Source

`FrameInfo`

pub struct FrameInfo {
  key : String
  path : ReadOnlyArray[Int]
  kind : @moonrockz/diagrams/sequence.FrameKind
  sections : ReadOnlyArray[SectionInfo]
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`FrameInfo::equal`

fn FrameInfo::equal(FrameInfo, FrameInfo) -> Bool

Source

`FrameInfo::not_equal`

fn FrameInfo::not_equal(x : FrameInfo, y : FrameInfo) -> Bool

Source

`FrameInfo::to_repr`

fn FrameInfo::to_repr(FrameInfo) -> @moonbitlang/core/debug.Repr

Source

`Graph`

pub struct Graph {
  view_id : String
  nodes : ReadOnlyArray[GraphNode]
  edges : ReadOnlyArray[GraphEdge]
  // private fields
}

Source

`Graph::lookup`

fn Graph::lookup(self : Graph, id : String, limits? : Limits) -> Result[GraphNode, QueryFailure]

Source

`Graph::reachable`

fn Graph::reachable(self : Graph, start : String, kinds? : ArrayView[EdgeKind], direction? : Direction, limits? : Limits) -> ReachabilityResult

Breadth-first discovery includes the selected start once. Associations never become control-flow edges; MessageFlow is explicit opt-in.

Source

`Graph::route`

fn Graph::route(self : Graph, start : String, target : String, kinds? : ArrayView[EdgeKind], direction? : Direction, limits? : Limits) -> RouteResult

One shortest structural route; authored edge order breaks equal-length ties. Reverse queries keep the original connection direction and identities.

Source

`GraphEdge`

pub struct GraphEdge {
  kind : EdgeKind
  source : String
  target : String
  occurrence : String?
  reversed : Bool
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`GraphEdge::equal`

fn GraphEdge::equal(GraphEdge, GraphEdge) -> Bool

Source

`GraphEdge::not_equal`

fn GraphEdge::not_equal(x : GraphEdge, y : GraphEdge) -> Bool

Source

`GraphEdge::to_repr`

fn GraphEdge::to_repr(GraphEdge) -> @moonbitlang/core/debug.Repr

Source

`GraphNode`

pub struct GraphNode {
  id : String
  label : String
  kind : NodeKind
  occurrence : String?
  source_node : @moonrockz/diagrams/bpmn.Node?
  swimlane_node : @moonrockz/diagrams/swimlane.Node?
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`GraphNode::equal`

fn GraphNode::equal(GraphNode, GraphNode) -> Bool

Source

`GraphNode::not_equal`

fn GraphNode::not_equal(x : GraphNode, y : GraphNode) -> Bool

Source

`GraphNode::to_repr`

fn GraphNode::to_repr(GraphNode) -> @moonbitlang/core/debug.Repr

Source

`LimitKind`

pub(all) enum LimitKind {
  Nodes
  Edges
  Results
  Work
  Steps
  Depth
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`LimitKind::equal`

fn LimitKind::equal(LimitKind, LimitKind) -> Bool

Source

`LimitKind::not_equal`

fn LimitKind::not_equal(x : LimitKind, y : LimitKind) -> Bool

Source

`LimitKind::to_repr`

fn LimitKind::to_repr(LimitKind) -> @moonbitlang/core/debug.Repr

Source

`Limits`

pub struct Limits {
  nodes : Int
  edges : Int
  steps : Int
  results : Int
  work : Int
  depth : Int
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Limits::equal`

fn Limits::equal(Limits, Limits) -> Bool

Source

`Limits::new`

fn Limits::new(nodes? : Int, edges? : Int, steps? : Int, results? : Int, work? : Int, depth? : Int) -> Limits

Source

`Limits::not_equal`

fn Limits::not_equal(x : Limits, y : Limits) -> Bool

Source

`Limits::to_repr`

fn Limits::to_repr(Limits) -> @moonbitlang/core/debug.Repr

Source

`Limits::valid`

fn Limits::valid(self : Limits) -> Bool

Source

`Motion`

pub(all) enum Motion {
  Step(String, Int64)
  OrientedStep(String, Int64, Bool)
  Visit(String, Int64)
  Serial(ReadOnlyArray[Motion])
  Parallel(ReadOnlyArray[Motion])
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Motion::equal`

fn Motion::equal(Motion, Motion) -> Bool

Source

`Motion::not_equal`

fn Motion::not_equal(x : Motion, y : Motion) -> Bool

Source

`Motion::parallel`

fn Motion::parallel(children : ArrayView[Motion]) -> Motion

Source

`Motion::serial`

fn Motion::serial(children : ArrayView[Motion]) -> Motion

Source

`Motion::to_repr`

fn Motion::to_repr(Motion) -> @moonbitlang/core/debug.Repr

Source

`MotionPlan`

pub struct MotionPlan {
  view_id : String
  flow_id : String
  duration_ms : Int
} derive(Eq, @moonbitlang/core/debug.Debug)

The first-slice pure plan names one authored connection and a duration.

Source

`MotionPlan::equal`

fn MotionPlan::equal(MotionPlan, MotionPlan) -> Bool

Source

`MotionPlan::new`

fn MotionPlan::new(view_id : String, flow_id : String, duration_ms? : Int) -> MotionPlan?

Source

`MotionPlan::not_equal`

fn MotionPlan::not_equal(x : MotionPlan, y : MotionPlan) -> Bool

Source

`MotionPlan::sample`

fn MotionPlan::sample(self : MotionPlan, elapsed_ms : Int) -> (Int, Int)

Exact bounded integer progress; no clock or browser state is read.

Source

`MotionPlan::to_repr`

fn MotionPlan::to_repr(MotionPlan) -> @moonbitlang/core/debug.Repr

Source

`NodeKind`

pub(all) enum NodeKind {
  Bpmn(@moonrockz/diagrams/bpmn.NodeKind)
  Message
  FrameEnter
  FrameExit
  Start
  End
  SwimlaneNode
  StateNode(@moonrockz/diagrams/state.State)
  StateRegion(@moonrockz/diagrams/state.Region)
  StateNote(@moonrockz/diagrams/state.Note)
  FlowchartNode(@moonrockz/diagrams/flowchart.Node)
  FlowchartGroup
  FlowchartLane
  FlowchartNote(@moonrockz/diagrams/flowchart.Note)
  FlowchartRegion(@moonrockz/diagrams/flowchart.Region, String)
  SwimlaneGroup
  SwimlaneLane
  ArchitectureService
  ArchitectureJunction
  ArchitectureGroup
  RailroadPoint
  DataValue
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`NodeKind::equal`

fn NodeKind::equal(NodeKind, NodeKind) -> Bool

Source

`NodeKind::not_equal`

fn NodeKind::not_equal(x : NodeKind, y : NodeKind) -> Bool

Source

`NodeKind::to_repr`

fn NodeKind::to_repr(NodeKind) -> @moonbitlang/core/debug.Repr

Source

`Occurrence`

pub struct Occurrence {
  key : String
  index : Int
  kind : OccurrenceKind
  path : ReadOnlyArray[Int]
  source : @moonrockz/diagrams/bpmn.SourceIdentity?
  flow : @moonrockz/diagrams/bpmn.Flow?
  message : @moonrockz/diagrams/sequence.Message?
  swimlane_connection : @moonrockz/diagrams/swimlane.Connection?
  railroad_connector : @moonrockz/diagrams/railroad-trace.Connector?
  railroad_term : @moonrockz/diagrams/railroad-trace.Term?
  data_member : @moonrockz/diagrams/data-tree.Member?
  data_node : @moonrockz/diagrams/data-tree.Node?
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Occurrence::equal`

fn Occurrence::equal(Occurrence, Occurrence) -> Bool

Source

`Occurrence::is_visit`

fn Occurrence::is_visit(self : Occurrence) -> Bool

True for a node-visit target, which has no connection path.

Source

`Occurrence::not_equal`

fn Occurrence::not_equal(x : Occurrence, y : Occurrence) -> Bool

Source

`Occurrence::to_repr`

fn Occurrence::to_repr(Occurrence) -> @moonbitlang/core/debug.Repr

Source

`OccurrenceKind`

pub(all) enum OccurrenceKind {
  Bpmn(@moonrockz/diagrams/bpmn.ConnectionKind)
  SequenceMessage
  Swimlane(@moonrockz/diagrams/swimlane.FlowDirection)
  State(@moonrockz/diagrams/state.Transition)
  Flowchart(@moonrockz/diagrams/flowchart.Connection)
  Architecture(@moonrockz/diagrams/architecture.Connection)
  Railroad(@moonrockz/diagrams/railroad-trace.ConnectorRole)
  DataConnector
  Visit(VisitKind)
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`OccurrenceKind::equal`

fn OccurrenceKind::equal(OccurrenceKind, OccurrenceKind) -> Bool

Source

`OccurrenceKind::not_equal`

fn OccurrenceKind::not_equal(x : OccurrenceKind, y : OccurrenceKind) -> Bool

Source

`OccurrenceKind::to_repr`

fn OccurrenceKind::to_repr(OccurrenceKind) -> @moonbitlang/core/debug.Repr

Source

`PlanResult`

pub struct PlanResult {
  plan : PlaybackPlan?
  diagnostics : ReadOnlyArray[@moonrockz/diagrams.Diagnostic]
}

Source

`PlaybackMode`

pub(all) enum PlaybackMode {
  Finite
  Illustrative
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`PlaybackMode::equal`

fn PlaybackMode::equal(PlaybackMode, PlaybackMode) -> Bool

Source

`PlaybackMode::not_equal`

fn PlaybackMode::not_equal(x : PlaybackMode, y : PlaybackMode) -> Bool

Source

`PlaybackMode::to_repr`

fn PlaybackMode::to_repr(PlaybackMode) -> @moonbitlang/core/debug.Repr

Source

`PlaybackPlan`

pub struct PlaybackPlan {
  view_id : String
  mode : PlaybackMode
  duration_ms : Int64
  steps : ReadOnlyArray[ScheduledStep]
  // private fields
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`PlaybackPlan::equal`

fn PlaybackPlan::equal(PlaybackPlan, PlaybackPlan) -> Bool

Source

`PlaybackPlan::illustrative`

fn PlaybackPlan::illustrative(catalog : Catalog, duration_ms? : Int64, kinds? : ArrayView[@moonrockz/diagrams/bpmn.ConnectionKind], limits? : Limits) -> PlanResult

The authored catalog is an illustration, including separate alternatives. Repeating it never asserts that these connections form a feasible execution.

Source

`PlaybackPlan::matches`

fn PlaybackPlan::matches(self : PlaybackPlan, catalog : Catalog) -> Bool

Source

`PlaybackPlan::not_equal`

fn PlaybackPlan::not_equal(x : PlaybackPlan, y : PlaybackPlan) -> Bool

Source

`PlaybackPlan::repeating`

fn PlaybackPlan::repeating(self : PlaybackPlan) -> PlanResult

Repeat a validated nonempty plan without changing its source or timing.

Source

`PlaybackPlan::route`

fn PlaybackPlan::route(catalog : Catalog, route : Route, duration_ms? : Int64, limits? : Limits) -> PlanResult

Source

`PlaybackPlan::sample_at`

fn PlaybackPlan::sample_at(self : PlaybackPlan, elapsed_ms : Int64) -> Sample

Source

`PlaybackPlan::scenario`

fn PlaybackPlan::scenario(catalog : Catalog, motion : Motion, limits? : Limits) -> PlanResult

Validate a finite, explicit scenario. Parallel children share a start and the following serial item waits for the longest branch, without stage barriers.

Source

`PlaybackPlan::sequence`

fn PlaybackPlan::sequence(catalog : Catalog, selections? : ArrayView[Selection], duration_ms? : Int64, limits? : Limits) -> PlanResult

Choose conditional sections and finite loop counts explicitly. Frame labels remain descriptions; the planner never evaluates their text.

Source

`PlaybackPlan::to_repr`

fn PlaybackPlan::to_repr(PlaybackPlan) -> @moonbitlang/core/debug.Repr

Source

`QueryFailure`

pub(all) enum QueryFailure {
  InvalidEndpoint(String)
  OutsideView(String)
  InvalidLimits
  Limit(LimitKind)
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`QueryFailure::equal`

fn QueryFailure::equal(QueryFailure, QueryFailure) -> Bool

Source

`QueryFailure::not_equal`

fn QueryFailure::not_equal(x : QueryFailure, y : QueryFailure) -> Bool

Source

`QueryFailure::to_repr`

fn QueryFailure::to_repr(QueryFailure) -> @moonbitlang/core/debug.Repr

Source

`ReachabilityResult`

pub(all) enum ReachabilityResult {
  Complete(ReadOnlyArray[GraphNode])
  Failed(QueryFailure)
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`ReachabilityResult::equal`

fn ReachabilityResult::equal(ReachabilityResult, ReachabilityResult) -> Bool

Source

`ReachabilityResult::not_equal`

fn ReachabilityResult::not_equal(x : ReachabilityResult, y : ReachabilityResult) -> Bool

Source

`ReachabilityResult::to_repr`

fn ReachabilityResult::to_repr(ReachabilityResult) -> @moonbitlang/core/debug.Repr

Source

`Route`

pub struct Route {
  view_id : String
  direction : Direction
  nodes : ReadOnlyArray[GraphNode]
  edges : ReadOnlyArray[GraphEdge]
  reversed : ReadOnlyArray[Bool]
  // private fields
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Route::equal`

fn Route::equal(Route, Route) -> Bool

Source

`Route::not_equal`

fn Route::not_equal(x : Route, y : Route) -> Bool

Source

`Route::to_repr`

fn Route::to_repr(Route) -> @moonbitlang/core/debug.Repr

Source

`RouteResult`

pub(all) enum RouteResult {
  Found(Route)
  Unreachable
  Failed(QueryFailure)
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`RouteResult::equal`

fn RouteResult::equal(RouteResult, RouteResult) -> Bool

Source

`RouteResult::not_equal`

fn RouteResult::not_equal(x : RouteResult, y : RouteResult) -> Bool

Source

`RouteResult::to_repr`

fn RouteResult::to_repr(RouteResult) -> @moonbitlang/core/debug.Repr

Source

`Sample`

pub struct Sample {
  elapsed_ms : Int64
  duration_ms : Int64
  finished : Bool
  active : ReadOnlyArray[Active]
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Sample::equal`

fn Sample::equal(Sample, Sample) -> Bool

Source

`Sample::not_equal`

fn Sample::not_equal(x : Sample, y : Sample) -> Bool

Source

`Sample::to_repr`

fn Sample::to_repr(Sample) -> @moonbitlang/core/debug.Repr

Source

`ScheduledStep`

pub struct ScheduledStep {
  ordinal : Int
  occurrence : Occurrence
  start_ms : Int64
  duration_ms : Int64
  concurrent_groups : ReadOnlyArray[Int]
  reversed : Bool
  visit : Bool
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`ScheduledStep::equal`

fn ScheduledStep::equal(ScheduledStep, ScheduledStep) -> Bool

Source

`ScheduledStep::not_equal`

fn ScheduledStep::not_equal(x : ScheduledStep, y : ScheduledStep) -> Bool

Source

`ScheduledStep::to_repr`

fn ScheduledStep::to_repr(ScheduledStep) -> @moonbitlang/core/debug.Repr

Source

`SectionInfo`

pub struct SectionInfo {
  role : @moonrockz/diagrams/sequence.SectionRole
  label : String?
  controls : ReadOnlyArray[Control]
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`SectionInfo::equal`

fn SectionInfo::equal(SectionInfo, SectionInfo) -> Bool

Source

`SectionInfo::not_equal`

fn SectionInfo::not_equal(x : SectionInfo, y : SectionInfo) -> Bool

Source

`SectionInfo::to_repr`

fn SectionInfo::to_repr(SectionInfo) -> @moonbitlang/core/debug.Repr

Source

`Selection`

pub struct Selection {
  frame_key : String
  choice : Choice
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Selection::equal`

fn Selection::equal(Selection, Selection) -> Bool

Source

`Selection::new`

fn Selection::new(frame_key : String, choice : Choice) -> Selection

Source

`Selection::not_equal`

fn Selection::not_equal(x : Selection, y : Selection) -> Bool

Source

`Selection::to_repr`

fn Selection::to_repr(Selection) -> @moonbitlang/core/debug.Repr

Source

`VisitKind`

pub(all) enum VisitKind {
  StateNode(@moonrockz/diagrams/state.Role)
  StateNote
  FlowchartNode(@moonrockz/diagrams/flowchart.Role)
  FlowchartNote
  RailroadTerm(@moonrockz/diagrams/railroad-trace.TermKind)
  DataRow
  DataBox
} derive(Eq, @moonbitlang/core/debug.Debug)

The kind of a node-visit target.

Source

`VisitKind::equal`

fn VisitKind::equal(VisitKind, VisitKind) -> Bool

Source

`VisitKind::not_equal`

fn VisitKind::not_equal(x : VisitKind, y : VisitKind) -> Bool

Source

`VisitKind::to_repr`

fn VisitKind::to_repr(VisitKind) -> @moonbitlang/core/debug.Repr

Source

Values

`data_key`

fn data_key(view_id : String, kind : String, id : String) -> String

The occurrence key of a data member row, data box or data connector.

Source

`max_duration_ms`

let max_duration_ms : Int64

Source

`railroad_key`

fn railroad_key(view_id : String, id : String) -> String

The occurrence key of a railroad term or connector identity.

Source