🥮 mooncakes.io
    Sign in

    moonrockz/diagrams/sequence does not have a README file

    LinkSource

    source
    pub(open) trait LinkSource {
      fn participant(Self, Link) -> ParticipantProperties?
      fn message(Self, Link) -> MessageProperties?
    }

    A pure adapter for a source such as a Smithy model. Implementations return only render properties. resolve keeps all diagram structure and links.

    Autonumber

    source
    pub(all) enum Autonumber {
      On(start~ : Double?, step~ : Double?)
      Off
    } derive(Eq, 
    Debug    )

    A numbering change at this point in the event stream.

    Autonumber::equal

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

    Autonumber::not_equal

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

    Autonumber::to_repr

    source

    BoxGroup

    source
    pub struct BoxGroup {
      id : String
      label : String
      colour : String?
    } derive(Eq, 
    Debug    )

    A box group. id distinguishes groups that have the same label.

    BoxGroup::equal

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

    BoxGroup::new

    source
    fn BoxGroup::new(id : String, label : String, colour? : String) -> BoxGroup

    BoxGroup::not_equal

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

    BoxGroup::to_repr

    source

    Event

    source
    pub(all) enum Event {
      Message(Message)
      Note(Note)
      Activate(String)
      Deactivate(String)
      Create(String)
      Destroy(String)
      Frame(Frame)
      Autonumber(Autonumber)
    } derive(Eq, 
    Debug    )

    One event of a sequence, in diagram order.

    Event::equal

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

    Event::not_equal

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

    Event::to_repr

    source

    Frame

    source
    pub struct Frame {
      kind : FrameKind
      sections : ReadOnlyArray[Section]
      colour : String?
    } derive(Eq, 
    Debug    )

    A nested frame. A first section is required; colour belongs to rect frames. The colour is stored on the frame rather than as a section label.

    Frame::equal

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

    Frame::new

    source
    fn Frame::new(kind : FrameKind, first : Section, rest? : ArrayView[Section], colour? : String) -> Frame

    Frame::not_equal

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

    Frame::to_repr

    source

    FrameKind

    source
    pub(all) enum FrameKind {
      Loop
      Alt
      Opt
      Par
      ParOver
      Critical
      Break
      Rect
    } derive(Eq, 
    Debug    )

    The meaning of a frame. ParOver permits overlapping parallel sections.

    FrameKind::equal

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

    FrameKind::not_equal

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

    FrameKind::to_repr

    source

    pub(all) enum Head {
      NoHead
      Arrow
      OpenArrow
      Cross
      Async
      HalfArrow(upper~ : Bool, filled~ : Bool)
      Central(Head)
    } derive(Eq, 
    Debug    )

    What a message line has at one of its ends.

    Head::equal

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

    Head::not_equal

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

    Head::to_repr

    source

    LineStyle

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

    The line of a message.

    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

    pub struct Link {
      scheme : LinkScheme
      target : String
    } derive(Eq, 
    Debug    )

    A format-independent link. Smithy targets use the canonical # spelling.

    Link::equal

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

    Link::new

    source
    fn Link::new(scheme : LinkScheme, target : String) -> Link

    Link::not_equal

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

    Link::to_repr

    source

    LinkScheme

    source
    pub(all) enum LinkScheme {
      Smithy
      OpenRpc
    } derive(Eq, 
    Debug    )

    The schemes understood by diagram adapters.

    LinkScheme::equal

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

    LinkScheme::not_equal

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

    LinkScheme::to_repr

    source

    Message

    source
    pub struct Message {
      sender : String
      receiver : String
      line : LineStyle
      sender_head : Head
      receiver_head : Head
      label : String
      link : Link?
      properties : MessageProperties?
      number : Double?
    } derive(Eq, 
    Debug    )

    A message from sender to receiver.

    Message::equal

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

    Message::new

    source
    fn Message::new(sender : String, receiver : String, label : String, line? : LineStyle, sender_head? : Head, receiver_head? : Head, link? : Link, properties? : MessageProperties, number? : Double) -> Message

    A message. The default is a solid line with an arrowhead at the receiver.

    Message::not_equal

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

    Message::to_repr

    source

    Message::with_properties

    source
    fn Message::with_properties(self : Message, properties : MessageProperties) -> Message

    MessageProperties

    source
    pub struct MessageProperties {
      sublabel : String?
      description : String?
    } derive(Eq, 
    Debug    )

    Additional message text supplied by an adapter.

    MessageProperties::equal

    source

    MessageProperties::new

    source
    fn MessageProperties::new(sublabel? : String, description? : String) -> MessageProperties

    MessageProperties::not_equal

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

    MessageProperties::to_repr

    source

    Note

    source
    pub struct Note {
      placement : Placement
      participants : ReadOnlyArray[String]
      text : String
    } derive(Eq, 
    Debug    )

    A note on one or more participants.

    Note::equal

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

    Note::new

    source
    fn Note::new(placement : Placement, participants : ArrayView[String], text : String) -> Note

    Note::not_equal

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

    Note::to_repr

    source

    Participant

    source
    pub struct Participant {
      id : String
      label : String
      kind : ParticipantKind
      group : BoxGroup?
      link : Link?
      properties : ParticipantProperties?
    } derive(Eq, 
    Debug    )

    One participant of a sequence. id is unique in the sequence.

    Participant::equal

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

    Participant::new

    source
    fn Participant::new(id : String, label? : String, kind? : ParticipantKind, group? : BoxGroup, link? : Link, properties? : ParticipantProperties) -> Participant

    A participant. The label is the id when no label is given.

    Participant::not_equal

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

    Participant::render_kind

    source
    fn Participant::render_kind(self : Participant) -> ParticipantKind

    The kind for rendering, falling back to the declared kind.

    Participant::to_repr

    source

    Participant::with_properties

    source
    fn Participant::with_properties(self : Participant, properties : ParticipantProperties) -> Participant

    Return a participant with new render properties, leaving the input unchanged.

    ParticipantKind

    source
    pub(all) enum ParticipantKind {
      Participant
      Actor
      Boundary
      Control
      Entity
      Database
      Collections
      Queue
      Service
      Resource
      Client
    } derive(Eq, 
    Debug    )

    What a participant is. A renderer uses the kind to select a style.

    ParticipantKind::equal

    source

    ParticipantKind::not_equal

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

    ParticipantKind::to_repr

    source

    ParticipantProperties

    source
    pub struct ParticipantProperties {
      kind : ParticipantKind?
      sublabel : String?
      description : String?
    } derive(Eq, 
    Debug    )

    Properties supplied by an adapter. The declared kind stays on the participant.

    ParticipantProperties::equal

    source

    ParticipantProperties::new

    source
    fn ParticipantProperties::new(kind? : ParticipantKind, sublabel? : String, description? : String) -> ParticipantProperties

    ParticipantProperties::not_equal

    source

    ParticipantProperties::to_repr

    source

    Placement

    source
    pub(all) enum Placement {
      LeftOf
      RightOf
      Over
    } derive(Eq, 
    Debug    )

    The placement of a note.

    Placement::equal

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

    Placement::not_equal

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

    Placement::to_repr

    source

    Resolution

    source
    pub struct Resolution {
      sequence : Sequence
      diagnostics : ReadOnlyArray[
    Diagnostic    ]
    }

    A resolved model and warnings for targets absent from the source.

    Section

    source
    pub struct Section {
      label : String?
      events : ReadOnlyArray[Event]
    } derive(Eq, 
    Debug    )

    One ordered section of a frame.

    Section::equal

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

    Section::new

    source
    fn Section::new(events : ArrayView[Event], label? : String) -> Section

    Section::not_equal

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

    Section::to_repr

    source

    Sequence

    source
    pub struct Sequence {
      participants : ReadOnlyArray[Participant]
      events : ReadOnlyArray[Event]
      title : String?
      accessibility_title : String?
      accessibility_description : String?
    } derive(Eq, 
    Debug    )

    A sequence diagram without a link to one diagram format.

    Sequence::equal

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

    Sequence::new

    source
    fn Sequence::new(participants : ArrayView[Participant], events : ArrayView[Event], title? : String, accessibility_title? : String, accessibility_description? : String) -> Sequence

    A sequence. The model keeps copies of participants and events, so a later change to the input arrays does not change it.

    Sequence::not_equal

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

    Sequence::participant

    source
    fn Sequence::participant(self : Sequence, id : String) -> Participant?

    The participant with the id id.

    Sequence::to_repr

    source

    resolve

    source
    fn[S : LinkSource] resolve(sequence : Sequence, source : S) -> Resolution

    Resolve links without changing the input or allowing the source to replace participants, events, labels, numbering or links. Existing properties remain when a source does not know a target.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io