@hpcc-js/wasm-graphviz 1.24.1 → 1.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hpcc-js/wasm-graphviz",
-  "version": "1.24.1",
+  "version": "1.25.0",
   "description": "hpcc-js - WASM Graphviz",
   "type": "module",
   "exports": {
@@ -18,7 +18,7 @@
   ],
   "scripts": {
     "clean": "rimraf coverage dist dist-test types .nyc_output",
-    "gen-types": "tsgo --project tsconfig.json --emitDeclarationOnly",
+    "gen-types": "tsc --project tsconfig.json --emitDeclarationOnly",
     "gen-types-watch": "npm run gen-types -- --watch",
     "bundle": "node esbuild.js",
     "bundle-dev": "npm run bundle -- --development",
@@ -56,5 +56,5 @@
   },
   "homepage": "https://hpcc-systems.github.io/hpcc-js-wasm/",
   "license": "Apache-2.0",
-  "gitHead": "66515f510e2045ad74b336a52f3ab55974ebed9e"
+  "gitHead": "e9302b649306927c2844eda31d3ee58b17b8eb8a"
 }

package/src/graphviz.ts

@@ -8,6 +8,22 @@ import type {
     GraphDotAttr, GraphAttrs as GraphAttrs
 } from "./types.ts";
 
+type AttrValues<T> = Partial<{ [K in keyof T]: NonNullable<T[K]> }>;
+
+function applyAttrs<T extends object>(
+    attrs: AttrValues<T> | undefined,
+    apply: (attr: string, value: string | number | boolean) => void
+): void {
+    if (!attrs) {
+        return;
+    }
+    for (const [attr, value] of Object.entries(attrs)) {
+        if (value !== undefined) {
+            apply(attr, value as string | number | boolean);
+        }
+    }
+}
+
 /**
  * Various graphic and data formats for end user, web, documents and other applications.  See [Output Formats](https://graphviz.org/docs/outputs/) for more information.
  */
@@ -117,6 +133,35 @@ let g_graphviz: Promise<Graphviz> | undefined;
  */
 export type GraphType = "directed" | "undirected" | "strict directed" | "strict undirected";
 
+export interface GraphInit {
+    name?: string;
+    type?: GraphType;
+    attrs?: AttrValues<GraphAttrs>;
+    htmlAttrs?: AttrValues<GraphAttrs>;
+}
+
+export interface NodeInit {
+    name: string;
+    attrs?: AttrValues<NodeAttrs>;
+    htmlAttrs?: AttrValues<NodeAttrs>;
+}
+
+export interface EdgeInit {
+    tail: string;
+    head: string;
+    key?: string;
+    attrs?: AttrValues<EdgeAttrs>;
+    htmlAttrs?: AttrValues<EdgeAttrs>;
+}
+
+export interface SubgraphInit {
+    name: string;
+    attrs?: AttrValues<ClusterAttrs>;
+    htmlAttrs?: AttrValues<ClusterAttrs>;
+}
+
+export type ClusterInit = SubgraphInit;
+
 /**
  * A subgraph (or cluster) inside a {@link Graph}.
  *
@@ -148,8 +193,15 @@ export class Subgraph {
     /**
      * Create (or find) a node and add it to this subgraph.
      */
-    addNode(name: string): this {
+    addNode(name: string): this;
+    addNode(init: NodeInit): this;
+    addNode(nameOrInit: string | NodeInit): this {
+        const init = typeof nameOrInit === "string" ? { name: nameOrInit } : nameOrInit;
+        const { name, attrs, htmlAttrs } = init;
+
         this._sg.addNode(name);
+        applyAttrs<NodeAttrs>(attrs, (attr, value) => this.setNodeAttr(name, attr, value));
+        applyAttrs<NodeAttrs>(htmlAttrs, (attr, value) => this.setNodeHtmlAttr(name, attr, value));
         return this;
     }
 
@@ -157,8 +209,23 @@ export class Subgraph {
      * Create an edge inside this subgraph.  Both endpoints are created
      * automatically if they do not already exist.
      */
-    addEdge(tail: string, head: string, key: string = ""): this {
-        this._sg.addEdge(tail, head, key);
+    addEdge(tail: string, head: string, key?: string): this;
+    addEdge(init: EdgeInit): this;
+    addEdge(tailOrInit: string | EdgeInit, head?: string, key: string = ""): this {
+        const init = typeof tailOrInit === "string"
+            ? { tail: tailOrInit, head: head!, key }
+            : tailOrInit;
+        const { tail, head: resolvedHead, key: resolvedKey = "", attrs, htmlAttrs } = init;
+
+        this._sg.addEdge(tail, resolvedHead, resolvedKey);
+        applyAttrs<EdgeAttrs>(attrs, (attr, value) => this.setEdgeAttr(tail, resolvedHead, resolvedKey, attr, value));
+        applyAttrs<EdgeAttrs>(htmlAttrs, (attr, value) => this.setEdgeHtmlAttr(tail, resolvedHead, resolvedKey, attr, value));
+        return this;
+    }
+
+    applyInit(init: SubgraphInit): this {
+        applyAttrs<ClusterAttrs>(init.attrs, (attr, value) => this.setAttr(attr, value));
+        applyAttrs<ClusterAttrs>(init.htmlAttrs, (attr, value) => this.setHtmlAttr(attr, value));
         return this;
     }
 
@@ -497,8 +564,15 @@ export class Graph {
      * Create a node.  If a node with this name already exists it is returned
      * unchanged.
      */
-    addNode(name: string): this {
+    addNode(name: string): this;
+    addNode(init: NodeInit): this;
+    addNode(nameOrInit: string | NodeInit): this {
+        const init = typeof nameOrInit === "string" ? { name: nameOrInit } : nameOrInit;
+        const { name, attrs, htmlAttrs } = init;
+
         this._graph.addNode(name);
+        applyAttrs<NodeAttrs>(attrs, (attr, value) => this.setNodeAttr(name, attr, value));
+        applyAttrs<NodeAttrs>(htmlAttrs, (attr, value) => this.setNodeHtmlAttr(name, attr, value));
         return this;
     }
 
@@ -508,8 +582,23 @@ export class Graph {
      * parallel edges between the same pair of nodes; omit (or pass `""`) for
      * an anonymous edge.
      */
-    addEdge(tail: string, head: string, key: string = ""): this {
-        this._graph.addEdge(tail, head, key);
+    addEdge(tail: string, head: string, key?: string): this;
+    addEdge(init: EdgeInit): this;
+    addEdge(tailOrInit: string | EdgeInit, head?: string, key: string = ""): this {
+        const init = typeof tailOrInit === "string"
+            ? { tail: tailOrInit, head: head!, key }
+            : tailOrInit;
+        const { tail, head: resolvedHead, key: resolvedKey = "", attrs, htmlAttrs } = init;
+
+        this._graph.addEdge(tail, resolvedHead, resolvedKey);
+        applyAttrs<EdgeAttrs>(attrs, (attr, value) => this.setEdgeAttr(tail, resolvedHead, resolvedKey, attr, value));
+        applyAttrs<EdgeAttrs>(htmlAttrs, (attr, value) => this.setEdgeHtmlAttr(tail, resolvedHead, resolvedKey, attr, value));
+        return this;
+    }
+
+    applyInit(init: GraphInit): this {
+        applyAttrs<GraphAttrs>(init.attrs, (attr, value) => this.setGraphAttr(attr, value));
+        applyAttrs<GraphAttrs>(init.htmlAttrs, (attr, value) => this.setGraphHtmlAttr(attr, value));
         return this;
     }
 
@@ -849,10 +938,13 @@ export class Graph {
      * cluster.setAttr("label", "My Cluster").addEdge("a", "b");
      * ```
      */
-    addSubgraph(name: string): Subgraph {
+    addSubgraph(name: string): Subgraph;
+    addSubgraph(init: SubgraphInit): Subgraph;
+    addSubgraph(nameOrInit: string | SubgraphInit): Subgraph {
+        const init = typeof nameOrInit === "string" ? { name: nameOrInit } : nameOrInit;
         // addSubgraph only returns null when the internal graph pointer is null,
         // which cannot happen while this Graph instance is alive.
-        return new Subgraph(this._graph.addSubgraph(name)!);
+        return new Subgraph(this._graph.addSubgraph(init.name)!).applyInit(init);
     }
 
     /**
@@ -1287,10 +1379,17 @@ export class Graphviz {
      * const svg = graphviz.dot(graph.toDot());
      * ```
      */
-    createGraph(name: string = "G", type: GraphType = "directed"): Graph {
-        const directed = !type.includes("undirected") ? 1 : 0;
-        const strict = type.startsWith("strict") ? 1 : 0;
-        return new Graph(new this._module.CGraph(name, directed, strict), this._module);
+    createGraph(name?: string, type?: GraphType): Graph;
+    createGraph(init: GraphInit): Graph;
+    createGraph(nameOrInit: string | GraphInit = "G", type: GraphType = "directed"): Graph {
+        const init = typeof nameOrInit === "string"
+            ? { name: nameOrInit, type }
+            : nameOrInit;
+        const resolvedName = init.name ?? "G";
+        const resolvedType = init.type ?? "directed";
+        const directed = !resolvedType.includes("undirected") ? 1 : 0;
+        const strict = resolvedType.startsWith("strict") ? 1 : 0;
+        return new Graph(new this._module.CGraph(resolvedName, directed, strict), this._module).applyInit(init);
     }
 
     /**

package/types/graphviz.d.ts

@@ -1,5 +1,8 @@
 import type { MainModule, CGraph as CGraphWasm, CSubgraph as CSubgraphWasm } from "../types/graphvizlib.js";
 import type { NodeDotAttr, NodeAttrs, EdgeDotAttr, EdgeAttrs, ClusterDotAttr, ClusterAttrs, GraphDotAttr, GraphAttrs as GraphAttrs } from "./types.ts";
+type AttrValues<T> = Partial<{
+    [K in keyof T]: NonNullable<T[K]>;
+}>;
 /**
  * Various graphic and data formats for end user, web, documents and other applications.  See [Output Formats](https://graphviz.org/docs/outputs/) for more information.
  */
@@ -64,6 +67,30 @@ export interface Options {
  * - `"strict undirected"` – undirected graph that disallows parallel edges and self-loops
  */
 export type GraphType = "directed" | "undirected" | "strict directed" | "strict undirected";
+export interface GraphInit {
+    name?: string;
+    type?: GraphType;
+    attrs?: AttrValues<GraphAttrs>;
+    htmlAttrs?: AttrValues<GraphAttrs>;
+}
+export interface NodeInit {
+    name: string;
+    attrs?: AttrValues<NodeAttrs>;
+    htmlAttrs?: AttrValues<NodeAttrs>;
+}
+export interface EdgeInit {
+    tail: string;
+    head: string;
+    key?: string;
+    attrs?: AttrValues<EdgeAttrs>;
+    htmlAttrs?: AttrValues<EdgeAttrs>;
+}
+export interface SubgraphInit {
+    name: string;
+    attrs?: AttrValues<ClusterAttrs>;
+    htmlAttrs?: AttrValues<ClusterAttrs>;
+}
+export type ClusterInit = SubgraphInit;
 /**
  * A subgraph (or cluster) inside a {@link Graph}.
  *
@@ -92,11 +119,14 @@ export declare class Subgraph {
      * Create (or find) a node and add it to this subgraph.
      */
     addNode(name: string): this;
+    addNode(init: NodeInit): this;
     /**
      * Create an edge inside this subgraph.  Both endpoints are created
      * automatically if they do not already exist.
      */
     addEdge(tail: string, head: string, key?: string): this;
+    addEdge(init: EdgeInit): this;
+    applyInit(init: SubgraphInit): this;
     /**
      * Remove a node from this subgraph only.  The node (and any edges
      * connecting it) remains in the root graph and all other subgraphs.
@@ -278,6 +308,7 @@ export declare class Graph {
      * unchanged.
      */
     addNode(name: string): this;
+    addNode(init: NodeInit): this;
     /**
      * Create an edge from `tail` to `head`.  Both nodes are created
      * automatically if they do not already exist.  `key` distinguishes
@@ -285,6 +316,8 @@ export declare class Graph {
      * an anonymous edge.
      */
     addEdge(tail: string, head: string, key?: string): this;
+    addEdge(init: EdgeInit): this;
+    applyInit(init: GraphInit): this;
     /**
      * Replace this graph with one parsed from DOT source using Graphviz cgraph
      * reading support.
@@ -461,6 +494,7 @@ export declare class Graph {
      * ```
      */
     addSubgraph(name: string): Subgraph;
+    addSubgraph(init: SubgraphInit): Subgraph;
     /**
      * Look up an existing subgraph by name without creating a new one.
      * Returns a {@link Subgraph} wrapper if a subgraph with that name exists,
@@ -722,6 +756,7 @@ export declare class Graphviz {
      * ```
      */
     createGraph(name?: string, type?: GraphType): Graph;
+    createGraph(init: GraphInit): Graph;
     /**
      * Parse DOT source into a mutable {@link Graph}.  The returned graph can
      * be queried, modified, rendered directly, or serialised back to DOT with
@@ -729,3 +764,4 @@ export declare class Graphviz {
      */
     read(dotSource: string): Graph;
 }
+export {};