Release 0.2.1

Reviewed-on: #9

README.md

@@ -15,7 +15,7 @@ This package lets you render sequence diagrams directly in Typst. The following
 <td>
 
 ```typst
-#import "@preview/chronos:0.1.0"
+#import "@preview/chronos:0.2.1"
 #chronos.diagram({
   import chronos: *
   _par("Alice")

TODO.md

@@ -22,6 +22,7 @@
 - [ ] Add args verification to catch user errors + pretty error messages
 - [ ] PlantUML parser
 - [ ] (Message numbering)
-- [ ] Different types of groups (alt/loop/etc.)
+- [ ] Mainframes
+- [x] Different types of groups (alt/loop/etc.)
 - [ ] Delays
 - [ ] Auto-fit in parent

docs/example.typ

@@ -5,7 +5,7 @@
   chronos: chronos
 )
 
-#let example(src, show-src: true, vertical: false, fill: true, wrap: true) = {
+#let example(src, show-src: true, vertical: false, fill: false, wrap: true) = {
   src = src.text
   let full-src = example-preamble + src
   let body = eval(full-src, scope: example-scope)
@@ -16,15 +16,15 @@
       box(
         stroke: black + 1pt,
         radius: .5em,
-        fill: if fill {color.white.darken(5%)} else {none},
+        fill: if fill {color.white.darken(2%)} else {none},
         if show-src {
-          let src-block = align(left, raw(src, lang: "typc"))
+          let src-block = raw(src, block: true, lang: "typc")
           table(
             columns: if vertical {1} else {2},
-            inset: 1em,
+            inset: 5pt,
             align: horizon + center,
             stroke: none,
-            img,
+            table.cell(inset: 1em, img),
             if vertical {table.hline()} else {table.vline()}, src-block
           )
         } else {

docs/examples.typ

@@ -1,8 +1,23 @@
 #import "example.typ": example
 
+#let seq-return = example(```
+_seq(
+  "Bob", "Alice",
+  comment: [hello],
+  enable-dst: true
+)
+_seq(
+  "Alice", "Alice",
+  comment: [some action]
+)
+_ret(comment: [bye])
+```)
+
 #let seq-comm-align = example(```
-_par("p1", display-name: "Start participant")
+_par("p1",
-_par("p2", display-name: "End participant")
+     display-name: "Start participant")
+_par("p2",
+     display-name: "End participant")
 let alignments = (
   "start", "end",
   "left", "right",
@@ -63,6 +78,45 @@ _grp("Group 1", desc: "Description", {
 })
 ```)
 
+#let alt = example(```
+_par("a", display-name: "Alice")
+_par("b", display-name: "Bob")
+
+_alt(
+  "first encounter", {
+    _seq("a", "b", comment: "Who are you ?")
+    _seq("b", "a", comment: "I'm Bob")
+  },
+
+  "know eachother", {
+    _seq("a", "b", comment: "Hello Bob")
+    _seq("b", "a", comment: "Hello Alice")
+  },
+
+  "best friends", {
+    _seq("a", "b", comment: "Hi !")
+    _seq("b", "a", comment: "Hi !")
+  }
+)
+```)
+
+#let loop = example(```
+_par("a", display-name: "Alice")
+_par("b", display-name: "Bob")
+
+_loop("default loop", {
+  _seq("a", "b", comment: "Are you here?")
+})
+_gap()
+_loop("min loop", min: 1, {
+  _seq("a", "b", comment: "Are you here?")
+})
+_gap()
+_loop("min-max loop", min: 1, max: 5, {
+  _seq("a", "b", comment: "Are you still here?")
+})
+```)
+
 #let sync = example(```
 _par("alice", display-name: "Alice")
 _par("bob", display-name: "Bob")
@@ -82,15 +136,58 @@ _sync({
 })
 ```)
 
-#let gaps-seps = example(```
+#let gaps = example(```
-_par("alice", display-name: "Alice")
+_par("a", display-name: "Alice")
-_par("bob", display-name: "Bob")
+_par("b", display-name: "Bob")
 
-_seq("alice", "bob", comment: "Hello")
+_seq("a", "b", comment: [message 1])
-_gap(size: 10)
+_seq("b", "a", comment: [ok], dashed: true)
-_seq("bob", "alice", comment: "Hi")
+_gap()
-_sep("Another day")
+_seq("a", "b", comment: [message 2])
-_seq("alice", "bob", comment: "Hello again")
+_seq("b", "a", comment: [ok], dashed: true)
+_gap(size: 40)
+_seq("a", "b", comment: [message 3])
+_seq("b", "a", comment: [ok], dashed: true)
+```)
+
+#let seps = example(```
+_par("a", display-name: "Alice")
+_par("b", display-name: "Bob")
+
+_sep[Initialization]
+_seq("a", "b", comment: [Request 1])
+_seq(
+  "b", "a",
+  comment: [Response 1],
+  dashed: true
+)
+
+_sep[Repetition]
+_seq("a", "b", comment: [Request 2])
+_seq(
+  "b", "a",
+  comment: [Response 2],
+  dashed: true
+)
+```)
+
+#let delays = example(```
+_par("a", display-name: "Alice")
+_par("b", display-name: "Bob")
+
+_seq("a", "b", comment: [Auth Request])
+_delay()
+_seq(
+  "b", "a",
+  comment: [Auth Response],
+  dashed: true
+)
+_delay(name: [5 minutes later])
+_seq(
+  "b", "a",
+  comment: [Good Bye !],
+  dashed: true
+)
 ```)
 
 #let notes-shapes = example(```

docs/gaps_seps.typ

@@ -1,8 +1,15 @@
-/// Creates a gap before the next element
-/// - size (int): Size of the gap
-#let _gap(size: 20) = {}
-
 /// Creates a separator before the next element
-/// #examples.gaps-seps
+/// #examples.seps
 /// - name (content): Name to display in the middle of the separator
 #let _sep(name) = {}
+
+/// Creates a delay before the next element
+/// #examples.delays
+/// - name (content, none): Name to display in the middle of the delay area
+/// - size (int): Size of the delay
+#let _delay(name: none, size: 30) = {}
+
+/// Creates a gap before the next element
+/// #examples.gaps
+/// - size (int): Size of the gap
+#let _gap(size: 20) = {}

docs/groups.typ

@@ -2,7 +2,7 @@
 /// #examples.grp
 /// - name (content): The group's name
 /// - desc (none, content): Optional description
-/// - type (str): The groups's type (unused for the moment)
+/// - type (str): The groups's type (should only be set through other functions like @@_alt() or @@_loop() )
 /// - elmts (array): Elements inside the group (can be sequences, other groups, notes, etc.)
 #let _grp(
   name,
@@ -11,9 +11,48 @@
   elmts
 ) = {}
 
-/// Synchronizes multiple sequences
+/// Creates an alt-else group of sequences
+/// 
+/// It contains at least one section but can have as many as needed
+/// #examples.alt
+/// - desc (content): The alt's label
+/// - elmts (array): Elements inside the alt's first section
+/// - ..args (content, array): Complementary "else" sections.\ You can add as many else sections as you need by passing a content (else section label) followed by an array of elements (see example)
+#let _alt(
+  desc,
+  elmts,
+  ..args
+)
+
+/// Creates a looped group of sequences
+/// #examples.loop
+/// - desc (content): Loop description
+/// - min (none, number): Optional lower bound of the loop
+/// - max (auto, number): Upper bound of the loop. If left as `auto` and `min` is set, it will be infinity (`'*'`)
+/// - elmts (array): Elements inside the group
+#let _loop(
+  desc,
+  min: none,
+  max: auto,
+  elmts
+) = {}
+
+/// Synchronizes multiple sequences\
+/// All elements inside a synchronized group will start at the same time
 /// #examples.sync
 /// - elmts (array): Synchronized elements (generally sequences or notes)
 #let _sync(
   elmts
 )
+
+/// Creates an optional group\
+/// This is a simple wrapper around @@_grp()
+/// - desc (content): Group description
+/// - elmts (array): Elements inside the group
+#let _opt(desc, elmts) = {}
+
+/// Creates a break group\
+/// This is a simple wrapper around @@_grp()
+/// - desc (content): Group description
+/// - elmts (array): Elements inside the group
+#let _break(desc, elmts) = {}

docs/participants.typ

@@ -49,3 +49,21 @@
   show-bottom: true,
   show-top: true,
 ) = {}
+
+/// Sets some options for columns between participants
+///
+/// Parameters `p1` and `p2` MUST be consecutive participants (also counting found/lost messages), but they do not need to be in the left to right order
+/// - p1 (str): The first neighbouring participant
+/// - p2 (str): The second neighbouring participant
+/// - width (auto, int, float, length): Optional fixed width of the column\ If the column's content (e.g. sequence comments) is larger, it will overflow
+/// - margin (int, float, length): Additional margin to add to the column\ This margin is not included in `width` and `min-width`, but rather added separately
+/// - min-width (int, float, length): Minimum width of the column\ If set to a larger value than `width`, the latter will be overriden
+/// - max-width (int, float, length, none): Maximum width of the column\ If set to a lower value than `width`, the latter will be overriden\ If set to `none`, no restriction is applied
+#let _col(
+  p1,
+  p2,
+  width: auto,
+  margin: 0,
+  min-width: 0,
+  max-width: none
+) = {}

docs/sequences.typ

@@ -42,6 +42,17 @@
   slant: none
 ) = {}
 
+/// Creates a return sequence
+/// #examples.seq-return
+/// - comment (none, content): Optional comment to display along the arrow
+#let _ret(comment: none) = {}
+
+/// Accepted values for `comment-align` argument of @@_seq()
+/// #examples.seq-comm-align
+#let comment-align = (
+  "start", "end", "left", "center", "right"
+)
+
 /// Accepted values for `event` argument of @@_evt()
 /// 
 /// `EVENTS = ("create", "destroy", "enable", "disable")`
@@ -52,9 +63,3 @@
 #let tips = (
   "", ">", ">>", "\\", "\\\\", "/", "//", "x", "o",
 )
-
-/// Accepted values for `comment-align` argument of @@_seq()
-/// #examples.seq-comm-align
-#let comment-align = (
-  "start", "end", "left", "center", "right"
-)

gallery.bash

@@ -1,27 +0,0 @@
-#!/bin/bash
-
-
-echo
-echo "Generating gallery PDFs"
-
-set -- ./gallery/*.typ
-cnt="$#"
-i=1
-for f
-do
-    f2="${f/typ/pdf}"
-    echo "($i/$cnt) $f -> $f2"
-    typst c --root ./ "$f" "$f2"
-    i=$((i+1))
-done
-
-set -- ./gallery/readme/*.typ
-cnt="$#"
-i=1
-for f
-do
-    f2="${f/typ/png}"
-    echo "($i/$cnt) $f -> $f2"
-    typst c --root ./ "$f" "$f2"
-    i=$((i+1))
-done

gallery/example1.typ

@@ -33,15 +33,38 @@ Alice <-- Bob: Another authentication Response
 #chronos.diagram({
   import chronos: *
   _seq("Alice", "Bob", comment: "Authentication Request")
-  _seq("Bob", "Alice", comment: "Authentication Failure")
 
-  _grp("My own label", desc: "My own label2", {
+  _alt(
-    _seq("Alice", "Log", comment: "Log attack start")
+    "successful case", {
-    _grp("loop", desc: "1000 times", {
+      _seq("Bob", "Alice", comment: "Authentication Accepted")
-      _seq("Alice", "Bob", comment: "DNS Attack")
+    },
-    })
+    "some kind of failure", {
-    _seq("Alice", "Bob", comment: "Log attack end")
+      _seq("Bob", "Alice", comment: "Authentication Failure")
+
+      _grp("My own label", desc: "My own label2", {
+        _seq("Alice", "Log", comment: "Log attack start")
+        _loop("1000 times", {
+          _seq("Alice", "Bob", comment: "DNS Attack")
+        })
+        _seq("Alice", "Log", comment: "Log attack end")
+      })
+    },
+    "Another type of failure", {
+      _seq("Bob", "Alice", comment: "Please repeat")
+    }
+  )
+})
+
+#chronos.diagram({
+  import chronos: *
+  _par("a", display-name: box(width: 1.5em, height: .5em), show-bottom: false)
+  _par("b", display-name: box(width: 1.5em, height: .5em), show-bottom: false)
+  _col("a", "b", width: 2cm)
+  _loop("a<1", min: 1, {
+    _seq("a", "b", end-tip: ">>")
+    _seq("b", "a", end-tip: ">>")
   })
+  _seq("a", "b", end-tip: ">>")
 })
 
 #chronos.diagram({
@@ -55,6 +78,15 @@ Alice <-- Bob: Another authentication Response
   _seq("Bob", "Alice", comment: "another authentication Response", dashed: true)
 })
 
+#chronos.diagram({
+  import chronos: *
+  _seq("Alice", "Bob", comment: "Authentication Request")
+  _delay()
+  _seq("Bob", "Alice", comment: "Authentication Response")
+  _delay(name: "5 minutes later")
+  _seq("Bob", "Alice", comment: "Good Bye !")
+})
+
 #chronos.diagram({
   import chronos: *
   _seq("Alice", "Bob", comment: "message 1")

gallery/example3.typ

@@ -145,3 +145,22 @@ chronos.diagram({
 
   _gap()
 })
+
+#chronos.diagram({
+  import chronos: *
+
+  _par("a", display-name: "Alice")
+  _par("b", display-name: "Bob")
+  _par("c", display-name: "Caleb")
+  _par("d", display-name: "Danny")
+  _par("e", display-name: "Erika")
+
+  _col("a", "b")
+  _col("b", "c", width: 2cm)
+  _col("c", "d", margin: .5cm)
+  _col("d", "e", min-width: 2cm)
+
+  //_seq("b", "c", comment: [Hello World !])
+  //_seq("c", "d", comment: [Hello World])
+  //_seq("d", "e", comment: [Hello World])
+})

justfile

@@ -0,0 +1,12 @@
+# Local Variables:
+# mode: makefile
+# End:
+gallery_dir := "./gallery"
+set shell := ["bash", "-uc"]
+
+manual:
+  typst c manual.typ manual.pdf
+
+gallery:
+  for f in "{{gallery_dir}}"/*.typ; do typst c --root . "$f" "${f%typ}pdf"; done
+  for f in "{{gallery_dir}}"/readme/*.typ; do typst c --root . "$f" "${f%typ}png"; done

manual.typ

@@ -1,4 +1,6 @@
-#import "@preview/tidy:0.3.0"
+#import "@preview/tidy:0.4.2"
+#import "@preview/codly:1.2.0": codly-init, codly
+#import "@preview/codly-languages:0.1.8": codly-languages
 #import "src/lib.typ" as chronos
 #import "src/participant.typ" as mod-par
 #import "docs/examples.typ"
@@ -6,32 +8,48 @@
 
 #let TYPST = image("gallery/typst.png", width: 1.5cm, height: 1.5cm, fit: "contain")
 
-#let doc-ref(target, full: false, var: false) = {
+#show: codly-init
-  let (module, func) = target.split(".")
+#codly(
-  let label-name = module + func
+  languages: codly-languages
-  let display-name = func
+)
-  if full {
+
-    display-name = target
+#set text(font: "Source Sans 3")
-  }
-  if not var {
-    label-name += "()"
-    display-name += "()"
-  }
-  link(label(label-name))[#display-name]
-}
 
 #set heading(numbering: (..num) => if num.pos().len() < 4 {
   numbering("1.1", ..num)
 })
+
+#align(center)[
+  #v(2cm)
+  #text(size: 2em)[*Chronos*]
+  
+  _v#chronos.version;_
+  #v(1cm)
+  #chronos.diagram({
+    import chronos: *
+    _par("u", display-name: [User], shape: "actor")
+    _par("wa", display-name: [Web App])
+    _par("tu", display-name: [Typst Universe], shape: "database")
+
+    _seq("u", "wa", comment: [Compile document], enable-dst: true)
+    _seq("wa", "tu", comment: [Fetch Chronos])
+    _seq("tu", "wa", dashed: true, slant: 10)
+    _seq("wa", "wa", comment: [Render])
+    _ret(comment: [Nice sequence diagram])
+  })
+]
+
+#pagebreak()
+
 #{
-  outline(indent: true, depth: 3)
+  outline(indent: auto, depth: 3)
 }
 #show link: set text(fill: blue)
 
 #set page(numbering: "1/1", header: align(right)[chronos #sym.dash.em v#chronos.version])
 #set page(
-  header: locate(loc => align(left)[chronos #sym.dash.em v#chronos.version]),
+  header: align(left)[chronos #sym.dash.em v#chronos.version],
-  footer: locate(loc => align(center, counter(page).display("1/1", both: true)))
+  footer: context align(center, counter(page).display("1/1", both: true))
 )
 
 = Introduction
@@ -40,14 +58,16 @@ This package lets you create nice sequence diagrams using the CeTZ package.
 
 = Usage
 
+#let import-stmt = "#import \"@preview/chronos:" + str(chronos.version) + "\""
+
 Simply import #link("https://typst.app/universe/package/chronos/")[chronos] and call the `diagram` function:
-#pad(left: 1em)[```typ
+#raw(block:true, lang: "typ", ```typ
-#import "@preview/chronos:0.1.0"
+$import
 #chronos.diagram({
   import chronos: *
   ...
 })
-```]
+```.text.replace("$import", import-stmt))
 
 = Examples
 
@@ -121,7 +141,11 @@ chronos.diagram({
 == Custom images
 
 #example(```
-let load-img(path) = image(path, width: 1.5cm, height: 1.5cm, fit:"contain")
+let load-img(path) = image(
+  path,
+  width: 1.5cm, height: 1.5cm,
+  fit:"contain"
+)
 let TYPST = load-img("../gallery/typst.png")
 let FERRIS = load-img("../gallery/ferris.png")
 let ME = load-img("../gallery/me.jpg")
@@ -148,14 +172,14 @@ chronos.diagram({
   read("docs/participants.typ"),
   name: "Participants",
   require-all-parameters: true,
+  old-syntax: true,
   scope: (
     chronos: chronos,
     mod-par: mod-par,
-    TYPST: TYPST,
+    TYPST: TYPST
-    doc-ref: doc-ref
   )
 )
-#tidy.show-module(par-docs, show-outline: false)
+#tidy.show-module(par-docs, show-outline: false, sort-functions: none)
 
 #pagebreak(weak: true)
 
@@ -163,9 +187,9 @@ chronos.diagram({
   read("docs/sequences.typ"),
   name: "Sequences",
   require-all-parameters: true,
+  old-syntax: true,
   scope: (
     chronos: chronos,
-    doc-ref: doc-ref,
     examples: examples
   )
 )
@@ -177,13 +201,13 @@ chronos.diagram({
   read("docs/groups.typ"),
   name: "Groups",
   require-all-parameters: true,
+  old-syntax: true,
   scope: (
     chronos: chronos,
-    doc-ref: doc-ref,
     examples: examples
   )
 )
-#tidy.show-module(grp-docs, show-outline: false)
+#tidy.show-module(grp-docs, show-outline: false, sort-functions: none)
 
 #pagebreak(weak: true)
 
@@ -191,13 +215,13 @@ chronos.diagram({
   read("docs/gaps_seps.typ"),
   name: "Gaps and separators",
   require-all-parameters: true,
+  old-syntax: true,
   scope: (
     chronos: chronos,
-    doc-ref: doc-ref,
     examples: examples
   )
 )
-#tidy.show-module(gap-sep-docs, show-outline: false)
+#tidy.show-module(gap-sep-docs, show-outline: false, sort-functions: none)
 
 #pagebreak(weak: true)
 
@@ -205,9 +229,9 @@ chronos.diagram({
   read("docs/notes.typ"),
   name: "Notes",
   require-all-parameters: true,
+  old-syntax: true,
   scope: (
     chronos: chronos,
-    doc-ref: doc-ref,
     examples: examples
   )
 )

src/diagram.typ

@@ -1,6 +1,7 @@
 #import "utils.typ": get-group-span, fit-canvas
 #import "renderer.typ": render
 #import "participant.typ" as participant: _par, PAR-SPECIALS
+#import "sequence.typ": _seq
 
 #let _gap(size: 20) = {
   return ((
@@ -18,6 +19,18 @@
   ),)
 }
 
+#let _col(p1, p2, width: auto, margin: 0, min-width: 0, max-width: none) = {
+  return ((
+    type: "col",
+    p1: p1,
+    p2: p2,
+    width: width,
+    margin: margin,
+    min-width: min-width,
+    max-width: max-width
+  ),)
+}
+
 #let diagram(elements, width: auto) = {
   if elements == none {
     return
@@ -27,11 +40,12 @@
   let elmts = elements
   let i = 0
 
-  // Flatten groups
+  let activation-history = ()
+
+  // Flatten groups + convert returns
   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 == "?" {
@@ -45,12 +59,41 @@
       elmts.at(i) = elmt
       elmts = (
         elmts.slice(0, i + 1) +
-        grp-elmts +
+        elmt.elmts +
         ((
-          type: "grp-end"
+          type: "grp-end",
+          start-i: i
         ),) +
         elmts.slice(i+1)
       )
+    } else if elmt.type == "grp-end" {
+      // Put back elements in group because they might have changed
+      elmts.at(elmt.start-i).elmts = elmts.slice(elmt.start-i + 1, i)
+
+    } else if elmt.type == "seq" {
+      if elmt.enable-dst {
+        activation-history.push(elmt)
+      }
+    } else if elmt.type == "evt" {
+      if elmt.event == "enable" {
+        for elmt2 in elmts.slice(0, i).rev() {
+          if elmt2.type == "seq" {
+            activation-history.push(elmt2)
+            break
+          }
+        }
+      }
+    } else if elmt.type == "ret" {
+      if activation-history.len() == 0 {
+        panic("Cannot return if no lifeline is activated")
+      }
+      let seq = activation-history.pop()
+      elmts.at(i) = _seq(
+        seq.p2, seq.p1,
+        comment: elmt.comment,
+        disable-src: true,
+        dashed: true
+      ).first()
     }
     i += 1
   }
@@ -119,6 +162,21 @@
       } else if elmt.side == "right" {
         linked.push("]")
       }
+
+      let pars = none
+      if type(elmt.pos) == str {
+        pars = (elmt.pos,)
+      } else if type(elmt.pos) == array {
+        pars = elmt.pos
+      }
+      if pars != none {
+        for par in pars {
+          if not participant._exists(participants, par) {
+            participants.push(_par(par).first())
+          }
+        }
+      }
+
       last-note = (
         elmt: elmt,
         i: i
@@ -174,7 +232,7 @@
 
   // Compute groups spans (horizontal)
   for (i, elmt) in elmts.enumerate() {
-    if elmt.type == "grp" {
+    if elmt.type == "grp" or elmt.type == "alt" {
       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)
@@ -187,7 +245,6 @@
     }
   }
 
-  set text(font: "Source Sans 3")
   let canvas = render(participants, elmts)
   fit-canvas(canvas, width: width)
 }

src/group.typ

@@ -1,4 +1,4 @@
-#import "@preview/cetz:0.2.2": draw
+#import "/src/cetz.typ": draw
 #import "consts.typ": *
 
 #let _grp(name, desc: none, type: "default", elmts) = {
@@ -11,6 +11,36 @@
   ),)
 }
 
+#let _alt(desc, elmts, ..args) = {
+  let all-elmts = ()
+  all-elmts += elmts
+  let args = args.pos()
+  for i in range(0, args.len(), step: 2) {
+    let else-desc = args.at(i)
+    let else-elmts = args.at(i + 1, default: ())
+    all-elmts.push((
+      type: "else",
+      desc: else-desc
+    ))
+    all-elmts += else-elmts
+  }
+
+  return _grp("alt", desc: desc, type: "alt", all-elmts)
+}
+
+#let _loop(desc, min: none, max: auto, elmts) = {
+  let name = "loop"
+  if min != none {
+    if max == auto {
+      max = "*"
+    }
+    name += "(" + str(min) + "," + str(max) + ")"
+  }
+  _grp(name, desc: desc, type: "loop", elmts)
+}
+#let _opt(desc, elmts) = grp("opt", desc: desc, type: "opt", elmts)
+#let _break(desc, elmts) = grp("break", desc: desc, type: "break", elmts)
+
 #let render(x0, x1, y0, y1, group) = {
   let shapes = ()
   let name = text(group.name, weight: "bold")
@@ -52,3 +82,18 @@
 
   return shapes
 }
+
+#let render-else(x0, x1, y, elmt) = {
+  let shapes = draw.line(
+    (x0, y),
+    (x1, y),
+    stroke: (dash: (2pt, 1pt), thickness: .5pt)
+  )
+  shapes += draw.content(
+    (x0, y),
+    text([\[#elmt.desc\]], weight: "bold", size: .8em),
+    anchor: "north-west",
+    padding: 3pt
+  )
+  return shapes
+}

src/lib.typ

@@ -1,9 +1,9 @@
-#let version = version(0, 1, 1)
+#let version = version(0, 2, 1)
-#import "diagram.typ": diagram, from-plantuml, _gap, _evt
+#import "diagram.typ": diagram, from-plantuml, _gap, _evt, _col
 
-#import "sequence.typ": _seq
+#import "sequence.typ": _seq, _ret
-#import "group.typ": _grp
+#import "group.typ": _grp, _loop, _alt, _opt, _break
 #import "participant.typ": _par
-#import "separator.typ": _sep
+#import "separator.typ": _sep, _delay
 #import "note.typ": _note
 #import "sync.typ": _sync

src/note.typ

@@ -1,4 +1,4 @@
-#import "@preview/cetz:0.2.2": draw
+#import "/src/cetz.typ": draw
 #import "consts.typ": *
 
 #let SIDES = (
@@ -25,6 +25,9 @@
       panic("Aligned notes can only be over a participant (got side '" + side + "')")
     }
   }
+  if color == auto {
+    color = COL-NOTE
+  }
   return ((
     type: "note",
     side: side,

src/participant.typ

@@ -1,4 +1,4 @@
-#import "@preview/cetz:0.2.2": draw
+#import "/src/cetz.typ": draw
 #import "consts.typ": *
 
 #let PAR-SPECIALS = "?[]"
@@ -13,6 +13,7 @@
   "queue",
   "custom"
 )
+#let DEFAULT-COLOR = rgb("#E2E2F0")
 
 #let _par(
   name,
@@ -20,11 +21,14 @@
   from-start: true,
   invisible: false,
   shape: "participant",
-  color: rgb("#E2E2F0"),
+  color: DEFAULT-COLOR,
   custom-image: none,
   show-bottom: true,
   show-top: true,
 ) = {
+  if color == auto {
+    color = DEFAULT-COLOR
+  }
   return ((
     type: "par",
     name: name,

src/renderer.typ

@@ -1,5 +1,5 @@
-#import "@preview/cetz:0.2.2": canvas, draw
+#import "/src/cetz.typ": canvas, draw
-#import "utils.typ": get-participants-i, get-style
+#import "utils.typ": get-participants-i, get-style, normalize-units
 #import "group.typ"
 #import "participant.typ"
 #import participant: PAR-SPECIALS
@@ -194,6 +194,40 @@
     }
     widths.at(i) = w
   }
+
+  for elmt in elements {
+    if elmt.type == "col" {
+      let i1 = pars-i.at(elmt.p1)
+      let i2 = pars-i.at(elmt.p2)
+      if calc.abs(i1 - i2) != 1 {
+        let i-min = calc.min(i1, i2)
+        let i-max = calc.max(i1, i2)
+        let others = pars-i.pairs()
+                           .sorted(key: p => p.last())
+                           .slice(i-min + 1, i-max)
+                           .map(p => "'" + p.first() + "'")
+                           .join(", ")
+        panic(
+          "Column participants must be consecutive (participants (" +
+          others +
+          ") are in between)"
+        )
+      }
+      let i = calc.min(i1, i2)
+
+      if elmt.width != auto {
+        widths.at(i) = normalize-units(elmt.width)
+      }
+
+      let width = widths.at(i)
+      width = calc.max(width, normalize-units(elmt.min-width))
+      if elmt.max-width != none {
+        width = calc.min(width, normalize-units(elmt.max-width))
+      }
+      widths.at(i) = width + normalize-units(elmt.margin)
+    }
+  }
+
   return widths
 }
 
@@ -211,6 +245,7 @@
 
   let draw-seq = sequence.render.with(pars-i, x-pos, participants)
   let draw-group = group.render.with()
+  let draw-else = group.render-else.with()
   let draw-sep = separator.render.with(x-pos)
   let draw-par = participant.render.with(x-pos)
   let draw-note = note.render.with(pars-i, x-pos)
@@ -252,6 +287,9 @@
         if g.at(1).max-i == elmt.max-i { g.at(3) += 1 }
         g
       })
+      if elmt.grp-type == "alt" {
+        elmt.insert("elses", ())
+      }
       groups.push((y, elmt, 0, 0))
       y -= m.height / 1pt
     
@@ -263,6 +301,21 @@
       let x1 = x-pos.at(group.max-i) + end-lvl * 10 + 20
       shapes += draw-group(x0, x1, start-y, y, group)
 
+      if group.grp-type == "alt" {
+        for (else-y, else-elmt) in group.elses {
+          shapes += draw-else(x0, x1, else-y, else-elmt)
+        }
+      }
+
+    // Alt's elses -> reserve space for label + store position
+    } else if elmt.type == "else" {
+      y -= Y-SPACE
+      let m = measure(text([\[#elmt.desc\]], weight: "bold", size: .8em))
+      groups.last().at(1).elses.push((
+        y, elmt
+      ))
+      y -= m.height / 1pt
+
     // Separator
     } else if elmt.type == "sep" {
       let shps
@@ -273,6 +326,26 @@
     } else if elmt.type == "gap" {
       y -= elmt.size
 
+    // Delay
+    } else if elmt.type == "delay" {
+      let y0 = y
+      let y1 = y - elmt.size
+      for (i, line) in lifelines.enumerate() {
+        line.lines.push(("delay-start", y0))
+        line.lines.push(("delay-end", y1))
+        lifelines.at(i) = line
+      }
+      if elmt.name != none {
+        let x0 = x-pos.first()
+        let x1 = x-pos.last()
+        shapes += draw.content(
+          ((x0 + x1) / 2, (y0 + y1) / 2),
+          anchor: "center",
+          elmt.name
+        )
+      }
+      y = y1
+    
     // Event
     } else if elmt.type == "evt" {
       let par-name = elmt.participant
@@ -385,6 +458,28 @@
           if event == "destroy" {
             destructions.push((x + lvl * LIFELINE-W / 2, line.at(1)))
           }
+        } else if event == "delay-start" {
+          draw.line(
+            (x, last-y),
+            (x, line.at(1)),
+            stroke: (
+              dash: "dashed",
+              paint: gray.darken(40%),
+              thickness: .5pt
+            )
+          )
+          last-y = line.at(1)
+        } else if event == "delay-end" {
+          draw.line(
+            (x, last-y),
+            (x, line.at(1)),
+            stroke: (
+              dash: "loosely-dotted",
+              paint: gray.darken(40%),
+              thickness: .8pt
+            )
+          )
+          last-y = line.at(1)
         }
       }
 

src/separator.typ

@@ -1,4 +1,4 @@
-#import "@preview/cetz:0.2.2": draw
+#import "/src/cetz.typ": draw
 #import "consts.typ": *
 
 #let _sep(name) = {
@@ -8,6 +8,14 @@
   ),)
 }
 
+#let _delay(name: none, size: 30) = {
+  return ((
+    type: "delay",
+    name: name,
+    size: size
+  ),)
+}
+
 #let render(x-pos, elmt, y) = {
   let shapes = ()
   y -= Y-SPACE

src/sequence.typ

@@ -1,9 +1,12 @@
-#import "@preview/cetz:0.2.2": draw, vector
+#import "/src/cetz.typ": draw, vector
 #import "consts.typ": *
 #import "participant.typ"
 #import "note.typ"
 
 #let get-arrow-marks(sym, color) = {
+  if sym == none {
+    return none
+  }
   if type(sym) == array {
     return sym.map(s => get-arrow-marks(s, color))
   }
@@ -85,24 +88,39 @@
   ),)
 }
 
+#let _ret(comment: none) = {
+  return ((
+    type: "ret",
+    comment: comment
+  ),)
+}
+
 #let render(pars-i, x-pos, participants, elmt, y, lifelines) = {
   let shapes = ()
 
   y -= Y-SPACE
 
+  let i1 = pars-i.at(elmt.p1)
+  let i2 = pars-i.at(elmt.p2)
+  let width = calc.abs(x-pos.at(i1) - x-pos.at(i2))
+
   let h = 0
+  let comment = if elmt.comment == none {none} else {
+    let w = calc.min(width * 1pt, measure(elmt.comment).width)
+    box(
+      width: if i1 == i2 {auto} else {w},
+      elmt.comment
+    )
+  }
   // Reserve space for comment
-  if elmt.comment != none {
+  if comment != none {
-    h = calc.max(h, measure(box(elmt.comment)).height / 1pt + 6)
+    h = calc.max(h, measure(comment).height / 1pt + 6)
   }
   if "linked-note" in elmt {
     h = calc.max(h, note.get-size(elmt.linked-note).height / 2)
   }
   y -= h
 
-  let i1 = pars-i.at(elmt.p1)
-  let i2 = pars-i.at(elmt.p2)
-
   let start-info = (
     i: i1,
     x: x-pos.at(i1),
@@ -159,7 +177,7 @@
     let m = measure(box(par.display-name))
     let f = if i1 > i2 {-1} else {1}
     end-info.x -= (m.width + PAR-PAD.last() * 2) / 2pt * f
-    shapes += participant.render(x-pos, par, y: end-info.y - CREATE-OFFSET)
+    shapes += participant.render(x-pos, par, y: end-info.y)
   }
 
   end-info.ll-lvl = lifelines.at(i2).level * LIFELINE-W / 2
@@ -234,7 +252,7 @@
       (x2, end-info.y)
     )
 
-    if elmt.comment != none {
+    if comment != none {
       comment-anchor = (
         start: if x-mid < x1 {"south-east"} else {"south-west"},
         end: if x-mid < x1 {"south-west"} else {"south-east"},
@@ -258,7 +276,7 @@
       (x2, end-info.y)
     )
 
-    if elmt.comment != none {
+    if comment != none {
       let start-pt = pts.first()
       let end-pt = pts.last()
       if elmt.start-tip != "" {
@@ -294,7 +312,7 @@
 
   // Start circle tip
   if is-circle-tip(elmt.start-tip) {
-    shapes += draw.circle(pts.first(), radius: CIRCLE-TIP-RADIUS, stroke: elmt.color, fill: none, name: "_circle-start-tip")
+    shapes += draw.circle(pts.first(), radius: CIRCLE-TIP-RADIUS, stroke: none, fill: elmt.color, name: "_circle-start-tip")
     pts.at(0) = "_circle-start-tip"
   
   // Start cross tip
@@ -316,7 +334,7 @@
 
   // End circle tip
   if is-circle-tip(elmt.end-tip) {
-    shapes += draw.circle(pts.last(), radius: 3, stroke: elmt.color, fill: none, name: "_circle-end-tip")
+    shapes += draw.circle(pts.last(), radius: 3, stroke: none, fill: elmt.color, name: "_circle-end-tip")
     pts.at(pts.len() - 1) = "_circle-end-tip"
   
   // End cross tip
@@ -338,27 +356,26 @@
 
   shapes += draw.line(..pts, ..style)
 
-  if elmt.comment != none {
+  if comment != none {
     shapes += draw.content(
       comment-pt,
-      elmt.comment,
+      comment,
       anchor: comment-anchor,
       angle: comment-angle,
       padding: 3pt
     )
   }
 
+  if elmt.create-dst {
+    let dst-line = lifelines.at(i2)
+    dst-line.lines.push(("create", end-info.y))
+    lifelines.at(i2) = dst-line
+  }
   if elmt.enable-dst {
     let dst-line = lifelines.at(i2)
     dst-line.lines.push(("enable", end-info.y, elmt.lifeline-style))
     lifelines.at(i2) = dst-line
   }
-  if elmt.create-dst {
-    end-info.y -= CREATE-OFFSET
-    let dst-line = lifelines.at(i2)
-    dst-line.lines.push(("create", end-info.y))
-    lifelines.at(i2) = dst-line
-  }
 
   if "linked-note" in elmt {
     let m = note.get-size(elmt.linked-note)

src/utils.typ

@@ -1,3 +1,12 @@
+#let normalize-units(value) = {
+  if type(value) == int or type(value) == float {
+    return value
+  }
+  if type(value) == length {
+    return value / 1pt
+  }
+  panic("Unsupported type '" + str(type(value)) + "'")
+}
 #let get-participants-i(participants) = {
   let pars-i = (:)
   for (i, p) in participants.enumerate() {
@@ -27,6 +36,9 @@
       max-i = calc.max(max-i, i1)
     }
   }
+  if max-i < min-i {
+    (min-i, max-i) = (max-i, min-i)
+  }
   return (min-i, max-i)
 }
 

typst.toml

@@ -1,7 +1,7 @@
 [package]
 name = "chronos"
-version = "0.1.1"
+version = "0.2.1"
-compiler = "0.11.0"
+compiler = "0.13.1"
 repository = "https://git.kb28.ch/HEL/chronos"
 entrypoint = "src/lib.typ"
 authors = [
@@ -11,4 +11,4 @@ categories = ["visualization"]
 license = "Apache-2.0"
 description = "A package to draw sequence diagrams with CeTZ"
 keywords = ["sequence", "diagram", "plantuml"]
-exclude = [ "gallery", "gallery.bash", "docs" ]
+exclude = [ "gallery", "justfile", "docs" ]