forked from HEL/chronos
145 lines
3.2 KiB
Typst
145 lines
3.2 KiB
Typst
#import "utils.typ": get-group-span
|
|
#import "renderer.typ": render
|
|
#import "participant.typ" as participant: _par, PAR-SPECIALS
|
|
|
|
#let _gap(size: 20) = {
|
|
return ((
|
|
type: "gap",
|
|
size: size
|
|
),)
|
|
}
|
|
|
|
#let _evt(participant, event) = {
|
|
return ((
|
|
type: "evt",
|
|
participant: participant,
|
|
event: event,
|
|
lifeline-style: auto
|
|
),)
|
|
}
|
|
|
|
#let diagram(elements) = {
|
|
if elements == none {
|
|
return
|
|
}
|
|
|
|
let participants = ()
|
|
let elmts = elements
|
|
let i = 0
|
|
|
|
// Flatten groups
|
|
while i < elmts.len() {
|
|
let elmt = elmts.at(i)
|
|
if elmt.type == "grp" {
|
|
let grp-elmts = elmt.elmts
|
|
elmt.elmts = elmt.elmts.map(e => {
|
|
if e.type == "seq" {
|
|
if e.p1 == "?" {
|
|
e.p1 = "?" + e.p2
|
|
} else if e.p2 == "?" {
|
|
e.p2 = e.p1 + "?"
|
|
}
|
|
}
|
|
e
|
|
})
|
|
elmts.at(i) = elmt
|
|
elmts = (
|
|
elmts.slice(0, i + 1) +
|
|
grp-elmts +
|
|
((
|
|
type: "grp-end"
|
|
),) +
|
|
elmts.slice(i+1)
|
|
)
|
|
}
|
|
i += 1
|
|
}
|
|
|
|
// List participants
|
|
let linked = ()
|
|
for elmt in elmts {
|
|
if elmt.type == "par" {
|
|
participants.push(elmt)
|
|
} else if elmt.type == "seq" {
|
|
if not participant._exists(participants, elmt.p1) {
|
|
participants.push(_par(elmt.p1).first())
|
|
}
|
|
if not participant._exists(participants, elmt.p2) {
|
|
let par = _par(elmt.p2, from-start: not elmt.create-dst).first()
|
|
participants.push(par)
|
|
|
|
} else if elmt.create-dst {
|
|
let i = participants.position(p => p.name == elmt.p2)
|
|
participants.at(i).from-start = false
|
|
}
|
|
|
|
if elmt.p1 == "?" {
|
|
linked.push("?" + elmt.p2)
|
|
} else {
|
|
linked.push(elmt.p1)
|
|
}
|
|
if elmt.p2 == "?" {
|
|
linked.push(elmt.p1 + "?")
|
|
} else {
|
|
linked.push(elmt.p2)
|
|
}
|
|
}
|
|
}
|
|
linked = linked.dedup()
|
|
|
|
let pars = participants
|
|
participants = ()
|
|
|
|
if "[" in linked {
|
|
participants.push(_par("[", invisible: true).first())
|
|
}
|
|
|
|
for (i, p) in pars.enumerate() {
|
|
let before = _par("?" + p.name, invisible: true).first()
|
|
let after = _par(p.name + "?", invisible: true).first()
|
|
|
|
if before.name in linked {
|
|
if participants.len() == 0 or not participants.last().name.ends-with("?") {
|
|
participants.push(before)
|
|
} else {
|
|
participants.insert(-1, before)
|
|
}
|
|
}
|
|
|
|
participants.push(p)
|
|
|
|
if after.name in linked {
|
|
participants.push(after)
|
|
}
|
|
}
|
|
if "]" in linked {
|
|
participants.push(_par("]", invisible: true).first())
|
|
}
|
|
|
|
// Add index to participant
|
|
for (i, p) in participants.enumerate() {
|
|
p.insert("i", i)
|
|
participants.at(i) = p
|
|
}
|
|
|
|
// Compute groups spans (horizontal)
|
|
for (i, elmt) in elmts.enumerate() {
|
|
if elmt.type == "grp" {
|
|
let (min-i, max-i) = get-group-span(participants, elmt)
|
|
elmts.at(i).insert("min-i", min-i)
|
|
elmts.at(i).insert("max-i", max-i)
|
|
} else if elmt.type == "seq" {
|
|
if elmt.p1 == "?" {
|
|
elmts.at(i).p1 = "?" + elmt.p2
|
|
} else if elmt.p2 == "?" {
|
|
elmts.at(i).p2 = elmt.p1 + "?"
|
|
}
|
|
}
|
|
}
|
|
|
|
render(participants, elmts)
|
|
}
|
|
|
|
#let from-plantuml(code) = {
|
|
let code = code.text
|
|
} |