feature: custom angles for smartart.cycle.basic

[JL710]

It would be cool if the angles for the steps in smartart.cycle.basic could be customized. Currently they are all spaced out equally. It would be cool if the angle/spacing between them could be modified.

[JL710]

I imagine it looking something like this:

#let basic(
  steps,
  arrow-style: auto,
  step-style: palette.red,
  equal-width: false,
  equal-height: false,
  ccw: false,
  radius: 2,
  offset-angle: 0deg,
  name: none,
  step-angles: none,
  ..style,
) = {
  draw.group(name: name, ctx => {
    draw.anchor("default", (0, 0))

    let style = styles.resolve(
      ctx.style,
      merge: style.named(),
      root: "cycle-basic",
      base: cycle-basic-default-style,
    )

    let n-steps = steps.len()
    let step-style-at = _get-style-at-func(step-style, n-steps)
    let arrow-style-at = _get-style-at-func(arrow-style, n-steps)

    let (
      sizes,
      largest-width,
      highest-height,
    ) = _get-steps-sizes(steps, ctx, style, step-style-at)

    let step-angles = if step-angles == none {
      steps.map(_ => 360deg / n-steps)
    } else {
      if step-angles.len() != n-steps {
        panic("There must be as many step-angles as steps")
      }
      for step-angle in step-angles {
        if type(step-angle) != angle {
          panic("Type of angles must be degree")
        }
      }
      step-angles
    }
    if not ccw {
      step-angles = step-angles.map(x => x * -1)
    }

    for (i, step) in steps.enumerate() {
      let angle = step-angles.slice(0, i + 1).sum() + 90deg + offset-angle
      let pos = (angle, radius)

      let step-style = style.steps + step-style-at(i)
      let padding = resolve-number(ctx, step-style.padding)

      let (w, h) = sizes.at(i)
      if equal-width {
        w = largest-width
      }
      if equal-height {
        h = highest-height
      }
      let step-name = "step-" + str(i)

      _draw-step(ctx, step, pos, step-style, step-name, w, h)
    }
    for i in range(n-steps) {
      let angle = step-angles.slice(0, i + 1).sum() + 90deg + offset-angle
      let arrow-style = style.arrows + arrow-style-at(i)
      let arrow-stroke = arrow-style.stroke
      let arrow-fill = arrow-style.fill
      let arrow-thickness = arrow-style.thickness
      if arrow-fill == "steps" {
        let s1 = style.steps + step-style-at(i)
        let s2 = style.steps + step-style-at(i + 1)
        arrow-fill = gradient.linear(s1.fill, s2.fill).sample(50%)
      }

      let angle-step = step-angles.at(i)
      let start-angle = angle + angle-step * 0.2
      let end-angle = angle + angle-step * 0.8

      let a1 = angle
      let a2 = angle + angle-step / 2
      let a3 = angle + angle-step
      let n(a) = {
        if a < -180deg {
          a += 360deg
        } else if a > 180deg {
          a -= 360deg
        }
        return a
      }
      a1 = n(a1)
      a2 = n(a2)
      a3 = n(a3)
      let pts = (
        (a1, radius),
        (a2, radius),
        (a3, radius),
      )
      if not ccw {
        pts = pts.rev()
      }
      draw.hide(draw.arc-through(
        ..pts,
        name: "arc-" + str(i),
      ))
      draw.intersections(
        "i-" + str(i),
        "step-" + str(i),
        "arc-" + str(i),
      )
      draw.intersections(
        "j-" + str(i),
        "step-" + str(calc.rem(i + 1, n-steps)),
        "arc-" + str(i),
      )

      draw.get-ctx(ctx => {
        let (_, p1) = coordinate.resolve(ctx, "i-" + str(i) + ".0")
        let (_, p2) = coordinate.resolve(ctx, "j-" + str(i) + ".0")
        let start-angle = calc.atan2(p1.at(0), p1.at(1))
        let end-angle = calc.atan2(p2.at(0), p2.at(1))
        if ccw != (start-angle < end-angle) {
          if ccw {
            end-angle += 360deg
          } else {
            end-angle -= 360deg
          }
        }
        let angle-d = end-angle - start-angle

          let prev = "step-" + str(i)
          start-angle += angle-d * 0.1
          end-angle -= angle-d * 0.1
          let arrow-name = "arrow-" + str(i)

          let marks = (end: "straight")
          if arrow-style.double {
            marks.insert("start", "straight")
          }

          let arrow-thickness = arrow-thickness
          if arrow-thickness != none {
            arrow-thickness = resolve-number(ctx, arrow-thickness)
          }

          // Curved
          if arrow-style.curved {
            // Thin arrow
            if arrow-thickness == none {
              draw.arc-through(
                (start-angle, radius),
                ((start-angle + end-angle) / 2, radius),
                (end-angle, radius),
                stroke: arrow-stroke,
                mark: marks,
                name: arrow-name,
              )

              // Thick arrow
            } else {
              _draw-arc-arrow(
                start-angle,
                end-angle,
                radius,
                arrow-thickness,
                arrow-fill,
                arrow-stroke,
                double: arrow-style.double,
                name: arrow-name,
              )
            }

            // Straight
          } else {
            let p1 = (start-angle, radius)
            let p2 = (end-angle, radius)
            if arrow-thickness == none {
              draw.line(
                p1,
                p2,
                stroke: arrow-stroke,
                mark: marks,
                name: arrow-name,
              )
            } else {
              _draw-arrow(
                p1,
                p2,
                arrow-thickness,
                arrow-fill,
                arrow-stroke,
                double: arrow-style.double,
                name: arrow-name,
              )
            }
          }
      })
    }
  })
}

But with this, I am getting errors in some cases (like with angles being 0 or to low) which I am unable to resolve by myself right now.