diagraph:0.3.1

packages/preview/diagraph/0.3.1/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Robotechnic
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/preview/diagraph/0.3.1/README.md

@@ -0,0 +1,100 @@
+# diagraph
+
+A simple Graphviz binding for Typst using the WebAssembly plugin system.
+
+## Usage
+
+### Basic usage
+
+
+You can render a Graphviz Dot string to a SVG image using the `render` function:
+
+```typ
+#render("digraph { a -> b }")
+```
+
+Alternatively, you can use `raw-render` to pass a `raw` instead of a string:
+
+<!--EXAMPLE(raw-render)-->
+````typ
+#raw-render(
+  ```dot
+  digraph {
+    a -> b
+  }
+  ```
+)
+````
+![raw-render](https://raw.githubusercontent.com/Robotechnic/diagraph/main/images/raw-render1.png)
+
+For more information about the Graphviz Dot language, you can check the [official documentation](https://graphviz.org/documentation/).
+
+### Advanced usage
+
+Check the [manual](https://raw.githubusercontent.com/Robotechnic/diagraph/main/doc/manual.pdf) for more information about the plugin.
+
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details
+
+## Changelog
+
+### 0.3.1
+
+- Updated graphviz version to 12.2.1
+- Fixed a bug with the font being incorrectly set
+- Added adjacency lists to the graph rendering possibilities
+
+### 0.3.0
+
+- Added support for edge labels
+- Added a manual generated with Typst
+- Updated graphviz version
+- Fix an error in math mode detection
+
+### 0.2.5
+
+- If the shape is point, the label isn't displayed
+- Now a minimum size is not enforced if the node label is empty
+- Added support for font alternatives
+
+### 0.2.4
+
+- Added support for xlabels which are now rendered by Typst
+- Added support for cluster labels which are now rendered by Typst
+- Fix a margin problem with the clusters
+
+### 0.2.3
+
+- Updated to typst 0.11.0
+- Added support for `fontcolor`, `fontsize` and `fontname` nodes attributes
+- Diagraph now uses a protocol generator to generate the wasm interface
+
+### 0.2.2
+
+- Fix an alignment issue
+- Added a better mathematic formula recognition for node labels
+
+### 0.2.1
+
+- Added support for relative lenghts in the `width` and `height` arguments
+- Fix various bugs
+
+### 0.2.0
+
+- Node labels are now handled by Typst
+
+### 0.1.2
+
+- Graphs are now scaled to make the graph text size match the document text size
+
+### 0.1.1
+
+- Remove the `raw-render-rule` show rule because it doesn't allow use of custom font and the `render` / `raw-render` functions are more flexible
+- Add the `background` parameter to the `render` and `raw-render` typst functions and default it to `transparent` instead of `white`
+- Add center attribute to draw graph in the center of the svg in the `render` c function
+
+### 0.1.0
+
+Initial working version

packages/preview/diagraph/0.3.1/adjacency.typ

@@ -0,0 +1,191 @@
+#import "internals.typ": render
+
+#let inches = (
+  "width",
+  "height",
+  "len",
+  "lheight",
+  "lwidth",
+  "margin",
+  "nodesep",
+  "page",
+  "size",
+  "vertices",
+)
+
+#let value-to-str(key, value) = {
+  if type(value) == length {
+    if key in inches {
+      str(value.to-absolute().inches())
+    } else {
+      str(value.to-absolute().pt())
+    }
+  } else if type(value) == color {
+    "\"" + value.to-hex() + "\""
+  } else if value == none {
+    "none"
+  } else if value == true {
+    "true"
+  } else if value == false {
+    "false"
+  } else {
+    "\"" + str(value) + "\""
+  }
+}
+
+#let dict-to-graph-args(args, sep: ";", parent: "") = {
+  for (key, value) in args {
+    if type(value) == dictionary {
+      if sep == "," {
+        panic("Invalid argument for " + parent + "[" + key + "=...]")
+      }
+      key + "[" + dict-to-graph-args(value, sep: ",", parent: key) + "]"
+    } else {
+      key + "=" + if type(value) == array {
+        "\"(" + value.map(value-to-str.with(key)).join(",") + ")\""
+      } else {
+        value-to-str(key, value)
+      }
+    } + sep
+  }
+}
+
+#let create-nodes(min, max) = {
+  range(min, max).map(str).join(";")
+}
+
+#let create-attributes(labels) = {
+  labels
+    .enumerate()
+    .map(label => {
+        if type(label.at(1)) == dictionary {
+          let _ = label.at(1).remove("label", default: "")
+          _ = label.at(1).remove("xlabel", default: "")
+          str(label.at(0)) + "[" + dict-to-graph-args(label.at(1), sep: ",") + "]"
+        }
+      })
+    .join("")
+}
+
+#let create-clusters(clusters) = {
+  clusters
+    .enumerate()
+    .map(cluster => {
+        let id = str(cluster.at(0))
+        let nodes = cluster.at(1)
+        "subgraph cluster_" + id + "{"
+        if type(nodes) == dictionary {
+          let _ = nodes.remove("label", default: "")
+          let subnodes = nodes.remove("nodes")
+          dict-to-graph-args(nodes)
+          subnodes.map(str).join(";")
+        } else {
+          nodes.map(str).join(";")
+        } 
+        "};"
+      })
+    .join("")
+}
+
+#let build-edges(adjacency, directed) = {
+  adjacency
+    .enumerate()
+    .map(edges-list => {
+        edges-list
+          .at(1)
+          .enumerate()
+          .map(edge => {
+              if edge.at(1) == none {
+                ""
+              } else {
+                str(edges-list.at(0))
+                if directed {
+                  " -> "
+                } else {
+                  " -- "
+                }
+                str(edge.at(0)) + ";"
+              }
+            })
+          .join("")
+      })
+    .join("")
+}
+
+#let adjacency(..args) = context {
+  if args.pos().len() != 1 {
+    panic("adjacency() requires one argument: an adjacency matrix")
+  }
+  let adjacency = args.at(0)
+  let graph-params = args.named()
+  let vertex-labels = graph-params.remove("vertex-labels", default: ())
+  let directed = graph-params.remove("directed", default: true)
+  let clusters = graph-params.remove("clusters", default: ())
+	let debug = graph-params.remove("debug", default: false)
+	let clip = graph-params.remove("clip", default: true)
+
+  render(
+    if directed {
+      "digraph"
+    } else {
+      "graph"
+    } + "{" + dict-to-graph-args(graph-params) + create-nodes(
+      0,
+      adjacency.len(),
+    ) + ";" + create-clusters(clusters) + create-attributes(vertex-labels) + build-edges(adjacency, directed) + "}",
+		debug: debug,
+		clip: clip,
+    labels: name => {
+      let id = int(name)
+      if id < vertex-labels.len() {
+        let label = vertex-labels.at(id)
+        if type(label) == dictionary {
+          label.at("label", default: "")
+        } else {
+          label
+        }
+      } else {
+        ""
+      }
+    },
+    xlabels: name => {
+      let id = int(name)
+      if id < vertex-labels.len() {
+        let label = vertex-labels.at(id)
+        if type(label) == dictionary {
+          label.at("xlabel", default: none)
+        } else {
+          none
+        }
+      } else {
+        none
+      }
+    },
+    edges: (name, edges) => {
+      let id = int(name)
+      let result = (:)
+      for edge in edges {
+        let edge-id = int(edge)
+        let label = adjacency.at(id).at(edge-id)
+        if label != none {
+          result.insert(edge, [#label])
+        }
+      }
+      result
+    },
+		clusters: (name) => {
+			let id = int(name.split("_").at(1))
+			if id < clusters.len() {
+				let cluster = clusters.at(id)
+				if type(cluster) == dictionary {
+					cluster.at("label", default: none)
+				} else {
+					none
+				}
+			} else {
+				none
+			}
+		}
+  )
+}
+