feat: allow element alignment based on ports for x analogue to y

Accept `(from: <anchor>, to: <port-id>)` for the `x` parameter of
elements, aligning the element's port with the anchor, analogous to the
existing form for `y`. Add a `ports-x` parameter for elements with
`auto-ports: false` and a `gallery/test_xalign` gallery entry.

README.md

@@ -3,7 +3,7 @@
 Circuiteria is a [Typst](https://typst.app) package for drawing block circuit diagrams using the [CeTZ](https://typst.app/universe/package/cetz) package.
 
 <p align="center">
-  <img src="./gallery/platypus.png" alt="Perry the platypus" alt="A platypus / Perry the Platypus meme made with colored rounded rectangles">
+  <img src="./gallery/platypus.png" alt="A platypus / Perry the Platypus meme made with colored rounded rectangles">
 </p>
 
 ## Examples

gallery/test_xalign.typ

@@ -0,0 +1,30 @@
+// Demonstrates the `(from: <anchor>, to: <port-id>)` port-alignment shorthand
+// for the `x` parameter (analogous to the existing shorthand for `y`).
+#import "/src/lib.typ": circuit, element, util, wire
+
+#set page(width: auto, height: auto, margin: .5cm)
+
+#circuit({
+  // Anchor block: absolute placement, with a single "addr" port on its
+  // north side (auto-centred horizontally by circuiteria).
+  element.block(
+    x: 0, y: 0, w: 2, h: 1.5,
+    id: "vcemem",
+    fill: util.colors.orange,
+    ports: (north: ((id: "addr"),), east: ((id: "out"),))
+  )
+
+  // This block's "addr" port (south side) is x-aligned with vcemem's "addr"
+  // port (north side), even though B is wider than vcemem and not
+  // horizontally aligned by default.
+  element.block(
+    x: (from: "vcemem-port-addr", to: "addr"),
+    y: (rel: 2, to: "vcemem.north"),
+    w: 4.5, h: 1,
+    id: "fsm",
+    fill: util.colors.yellow,
+    ports: (south: ((id: "addr"),), east: ((id: "out"),))
+  )
+
+  wire.wire("wAddr", ("vcemem-port-addr", "fsm-port-addr"), style: "zigzag")
+})

gallery/test_yrel.typ

@@ -0,0 +1,46 @@
+// Demonstrates the `(rel: <number>, to: <anchor>)` shorthand for the `y`
+// parameter (analogous to the existing shorthand for `x`).
+#import "/src/lib.typ": circuit, element, util, wire
+
+#set page(width: auto, height: auto, margin: .5cm)
+
+#circuit({
+  // Anchor block: absolute placement.
+  element.block(
+    x: 0, y: 0, w: 2, h: 1.5,
+    id: "A",
+    fill: util.colors.orange,
+    ports: (east: ((id: "out"),))
+  )
+
+  // X relative, Y absolute (existing feature).
+  element.block(
+    x: (rel: 1, to: "A.east"), y: 0, w: 2, h: 1.5,
+    id: "B",
+    fill: util.colors.yellow,
+    ports: (west: ((id: "in"),), east: ((id: "out"),))
+  )
+
+  // Both X and Y relative to another element's anchor (new feature).
+  element.block(
+    x: (rel: 1, to: "B.east"),
+    y: (rel: 2, to: "B.south-west"),
+    w: 2, h: 1.5,
+    id: "C",
+    fill: util.colors.green,
+    ports: (west: ((id: "in"),))
+  )
+
+  // Y relative only, X absolute.
+  element.block(
+    x: 0,
+    y: (rel: -2.5, to: "A.south-west"),
+    w: 2, h: 1.5,
+    id: "D",
+    fill: util.colors.blue,
+    ports: (east: ((id: "out"),))
+  )
+
+  wire.wire("wAB", ("A-port-out", "B-port-in"))
+  wire.wire("wBC", ("B-port-out", "C-port-in"), style: "zigzag")
+})

src/elements/element.typ

@@ -21,10 +21,14 @@
 /// - draw-shape (function): Draw function
 /// - x (number, dictionary): The x position (bottom-left corner).
 ///
-///   If it is a dictionary, it should be in the format `(rel: number, to: str)`, where `rel` is the offset and `to` the base anchor
+///   If it is a dictionary, it can take one of two forms:
+///     - `(rel: number, to: str)`: `rel` is the x offset and `to` the base anchor
+///     - `(from: str, to: str)`: `from` is the base anchor and `to` is the id of the port to align with the anchor (analogous to `y`)
 /// - y (number, dictionary): The y position (bottom-left corner).
 ///
-///   If it is a dictionary, it should be in the format `(from: str, to: str)`, where `from` is the base anchor and `to` is the id of the port to align with the anchor
+///   If it is a dictionary, it can take one of two forms:
+///     - `(rel: number, to: str)`: `rel` is the y offset and `to` the base anchor (analogous to `x`)
+///     - `(from: str, to: str)`: `from` is the base anchor and `to` is the id of the port to align with the anchor
 /// - w (number): Width of the element
 /// - h (number): Height of the element
 /// - name (none, str): Optional name of the block
@@ -39,6 +43,7 @@
 /// - stroke (stroke): Border stroke
 /// - id (str): The block id (for future reference)
 /// - auto-ports (bool): Whether to use auto port placements or not. If false, `draw-shape` is responsible for adding the appropiate ports
+/// - ports-x (dictionary): Dictionary of the ports x offsets (used with `auto-ports: false`)
 /// - ports-y (dictionary): Dictionary of the ports y offsets (used with `auto-ports: false`)
 /// - debug (dictionary): Dictionary of debug options.
 ///
@@ -58,6 +63,7 @@
   stroke: black + 1pt,
   id: "",
   auto-ports: true,
+  ports-x: (:),
   ports-y: (:),
   debug: (
     ports: false
@@ -73,14 +79,45 @@
   if w == none { panic("Parameter w must be set") }
   if h == none { panic("Parameter h must be set") }
 
-  if (type(x) == dictionary) {
-    let offset = x.rel
+  if (type(x) == dictionary and "rel" in x) {
+    x = util.resolve-rel-coord(ctx, x, 0)
+  } else if (type(x) == dictionary) {
+    let from = x.from
     let to = x.to
-    let (ctx, to-pos) = coordinate.resolve(ctx, (rel: (offset, 0), to: to))
-    x = to-pos.at(0)
+    let (to-side, i) = find-port(ports, to)
+    let margins = (0%, 0%)
+    if to-side in ports-margins {
+      margins = ports-margins.at(to-side)
+    }
+
+    let dx
+    let left-margin
+    if to-side in ("north", "south") {
+      let used-pct = 100% - margins.at(0) - margins.at(1)
+      let used-width = width * used-pct / 100%
+      left-margin = width * margins.at(0) / 100%
+
+      dx = used-width * (i + 1) / (ports.at(to-side).len() + 1)
+
+      if not auto-ports {
+        left-margin = 0
+        dx = ports-x.at(to)(width)
+      }
+    } else if to-side == "west" {
+      dx = 0
+      left-margin = 0
+    } else if to-side == "east" {
+      dx = width
+      left-margin = 0
+    }
+
+    let (ctx, from-pos) = coordinate.resolve(ctx, from)
+    x = from-pos.at(0) + dx - width + left-margin
   }
   
-  if (type(y) == dictionary) {
+  if (type(y) == dictionary and "rel" in y) {
+    y = util.resolve-rel-coord(ctx, y, 1)
+  } else if (type(y) == dictionary) {
     let from = y.from
     let to = y.to
     let (to-side, i) = find-port(ports, to)

src/elements/logic/gate.typ

@@ -1,4 +1,5 @@
 #import "/src/cetz.typ": draw, coordinate
+#import "/src/util.typ"
 #import "../ports.typ": add-ports, add-port
 #import "../element.typ"
 
@@ -49,13 +50,12 @@
   if h == none { panic("Parameter h must be set") }
 
   if (type(x) == dictionary) {
-    let offset = x.rel
-    let to = x.to
-    let (ctx, to-pos) = coordinate.resolve(ctx, (rel: (offset, 0), to: to))
-    x = to-pos.at(0)
+    x = util.resolve-rel-coord(ctx, x, 0)
   }
   
-  if (type(y) == dictionary) {
+  if (type(y) == dictionary and "rel" in y) {
+    y = util.resolve-rel-coord(ctx, y, 1)
+  } else if (type(y) == dictionary) {
     let from = y.from
     let to = y.to
     

src/elements/logic/iec_gate.typ

@@ -1,4 +1,5 @@
 #import "/src/cetz.typ": draw, coordinate
+#import "/src/util.typ"
 #import "../ports.typ": add-ports, add-port
 #import "../element.typ"
 
@@ -60,13 +61,12 @@
   if h == none { panic("Parameter h must be set") }
 
   if (type(x) == dictionary) {
-    let offset = x.rel
-    let to = x.to
-    let (ctx, to-pos) = coordinate.resolve(ctx, (rel: (offset, 0), to: to))
-    x = to-pos.at(0)
+    x = util.resolve-rel-coord(ctx, x, 0)
   }
   
-  if (type(y) == dictionary) {
+  if (type(y) == dictionary and "rel" in y) {
+    y = util.resolve-rel-coord(ctx, y, 1)
+  } else if (type(y) == dictionary) {
     let from = y.from
     let to = y.to
     

src/util.typ

@@ -1,3 +1,23 @@
+#import "cetz.typ": coordinate
+
+/// Resolves a relative coordinate shorthand of the form `(rel: <number>, to: <anchor>)`
+/// to a single scalar along the requested axis.
+///
+/// Used to implement the shared `(rel:, to:)` shorthand accepted by the `x` and
+/// `y` parameters of `elmt`, `gate` and `iec-gate`.
+///
+/// - ctx (dictionary): The current CeTZ context
+/// - val (dictionary): A dictionary with fields `rel` (number) and `to` (anchor)
+/// - axis (int): `0` for x, `1` for y
+/// -> number
+#let resolve-rel-coord(ctx, val, axis) = {
+  let offset = val.rel
+  let to = val.to
+  let delta = if axis == 0 { (offset, 0) } else { (0, offset) }
+  let (_, to-pos) = coordinate.resolve(ctx, (rel: delta, to: to))
+  return to-pos.at(axis)
+}
+
 /// Predefined color palette
 /// #let w = 4
 /// #box(width: 100%, align(center)[