@graphty/graph-io 0.3.43 → 0.3.45

package/src/formats/dot/importer.ts

@@ -101,6 +101,8 @@ import {
     SOURCE_PORT_COLUMN,
     TARGET_PORT_COLUMN,
 } from "./names.js";
+import { dotPositions } from "./positions.js";
+import { dotStyles } from "./styles.js";
 import { DotSyntaxError, type DotToken, DotTokenizer } from "./tokenizer.js";
 
 /**
@@ -333,6 +335,8 @@ export const dotImporter: GraphImporter<DotImportOptions> = Object.freeze({
     options: Object.freeze(["keepPositionSource", "mismatchedEdgeOperator", "positions"]),
     extensions: EXTENSIONS,
     mimeTypes: MIME_TYPES,
+    styles: dotStyles,
+    positions: dotPositions,
 
     /**
      * Confidence that the head of an input is DOT: the `[strict] graph | digraph` header after
@@ -920,22 +924,43 @@ class DotParser {
             }
             throw new DotSyntaxError(`unexpected ${describeToken(token)} at the start of a statement`, token.line);
         }
-        if (!token.quoted && !token.html) {
-            const keyword = token.text.toLowerCase();
-            if (keyword === "node" || keyword === "edge" || keyword === "graph") {
-                lexer.next();
-                this.attributeStatement(scope, keyword, token.line);
-                return;
-            }
-            if (keyword === "subgraph") {
-                const group = this.subgraph(scope);
-                this.maybeEdgeStatement(scope, group, token.line);
-                return;
-            }
-            if (keyword === "digraph" || keyword === "strict") {
-                throw new DotSyntaxError(`unexpected keyword ${describeToken(token)} inside a graph`, token.line);
-            }
+        if (!token.quoted && !token.html && this.keywordStatement(scope, token)) {
+            return;
+        }
+        this.idStatement(scope);
+    }
+
+    /**
+     * Parse a statement that starts with a keyword: an attribute statement or a subgraph.
+     * @param scope - the scope
+     * @param token - the statement's first token, not yet read
+     * @returns false when the token is no statement keyword (an ID)
+     */
+    private keywordStatement(scope: Scope, token: DotToken): boolean {
+        const keyword = token.text.toLowerCase();
+        if (keyword === "node" || keyword === "edge" || keyword === "graph") {
+            this.lexer.next();
+            this.attributeStatement(scope, keyword, token.line);
+            return true;
+        }
+        if (keyword === "subgraph") {
+            const group = this.subgraph(scope);
+            this.maybeEdgeStatement(scope, group, token.line);
+            return true;
         }
+        if (keyword === "digraph" || keyword === "strict") {
+            throw new DotSyntaxError(`unexpected keyword ${describeToken(token)} inside a graph`, token.line);
+        }
+        return false;
+    }
+
+    /**
+     * Parse a statement that starts with an ID: `ID = ID`, a node statement, or an edge statement starting with a
+     * node.
+     * @param scope - the scope
+     */
+    private idStatement(scope: Scope): void {
+        const { lexer } = this;
         // ID '=' ID, a node statement, or an edge statement starting with a node
         const id = this.identifier();
         if (isPunct(lexer.peek(), "=")) {
@@ -945,6 +970,10 @@ class DotParser {
             return;
         }
         const port = this.port();
+        if (isPunct(lexer.peek(), ",")) {
+            this.nodeListStatement(scope, [{ id, port }, ...this.moreNodes()]);
+            return;
+        }
         if (isEdgeOp(lexer.peek())) {
             const endpoint = this.mentionEndpoint(scope, id, port);
             this.edgeStatement(scope, endpoint === null ? [] : [endpoint], id.line);
@@ -953,6 +982,37 @@ class DotParser {
         this.nodeStatement(scope, id, port);
     }
 
+    /**
+     * Read the rest of a node list after its first node: `, ID [port]` repeated (`a, b, c`).
+     * @returns the further nodes, in order
+     */
+    private moreNodes(): { id: DotToken; port: string | null }[] {
+        const out: { id: DotToken; port: string | null }[] = [];
+        while (isPunct(this.lexer.peek(), ",")) {
+            this.lexer.next();
+            const id = this.identifier();
+            out.push({ id, port: this.port() });
+        }
+        return out;
+    }
+
+    /**
+     * A statement starting with a node list (`a, b [attrs]` or `a, b -> c`): an edge statement from every node of
+     * the list, or a node statement for each.
+     * @param scope - the scope
+     * @param nodes - the listed nodes with their ports
+     */
+    private nodeListStatement(scope: Scope, nodes: readonly { id: DotToken; port: string | null }[]): void {
+        if (isEdgeOp(this.lexer.peek())) {
+            this.edgeStatement(scope, this.mentionAll(scope, nodes), nodes[0].id.line);
+            return;
+        }
+        const attributes = this.attributeList();
+        for (const n of nodes) {
+            this.applyNodeStatement(scope, n.id, n.port, attributes);
+        }
+    }
+
     /**
      * Read an ID, concatenating quoted strings joined by `+`.
      * @returns the id token (the concatenation keeps the first token's line and quoted flag)
@@ -1296,7 +1356,22 @@ class DotParser {
      * @param port - the port, if any (dropped with a warning)
      */
     private nodeStatement(scope: Scope, id: DotToken, port: string | null): void {
-        const attributes = this.attributeList();
+        this.applyNodeStatement(scope, id, port, this.attributeList());
+    }
+
+    /**
+     * Mention a node of a node statement and apply the statement's attributes to it.
+     * @param scope - the scope
+     * @param id - the id token
+     * @param port - the port, if any (dropped with a warning)
+     * @param attributes - the statement's attributes
+     */
+    private applyNodeStatement(
+        scope: Scope,
+        id: DotToken,
+        port: string | null,
+        attributes: readonly DotAttribute[],
+    ): void {
         const endpoint = this.mentionEndpoint(scope, id, null);
         if (endpoint === null) {
             return;
@@ -1344,21 +1419,37 @@ class DotParser {
                 groups.push(this.subgraph(scope));
             } else {
                 const id = this.identifier();
-                const port = this.port();
-                const endpoint = this.mentionEndpoint(scope, id, port);
-                groups.push(endpoint === null ? [] : [endpoint]);
+                groups.push(this.mentionAll(scope, [{ id, port: this.port() }, ...this.moreNodes()]));
             }
         }
         const attributes = this.attributeList();
         for (let k = 0; k < kinds.length; k++) {
+            const targets = groups[k + 1];
             for (const source of groups[k]) {
-                for (const target of groups[k + 1]) {
+                for (const target of targets) {
                     this.pushEdge(scope, source, target, kinds[k], attributes, line);
                 }
             }
         }
     }
 
+    /**
+     * Mention each listed node as an edge endpoint.
+     * @param scope - the scope
+     * @param nodes - the nodes with their ports
+     * @returns the endpoints of the nodes that could be created
+     */
+    private mentionAll(scope: Scope, nodes: readonly { id: DotToken; port: string | null }[]): Endpoint[] {
+        const group: Endpoint[] = [];
+        for (const n of nodes) {
+            const endpoint = this.mentionEndpoint(scope, n.id, n.port);
+            if (endpoint !== null) {
+                group.push(endpoint);
+            }
+        }
+        return group;
+    }
+
     /**
      * The direction of an edge from its operator, checked against the graph keyword.
      * @param op - the operator token

package/src/formats/dot/index.ts

@@ -6,3 +6,4 @@
 
 export { DOT_LOSS, dotExporter, type DotExportOptions } from "./exporter.js";
 export { DOT_ISSUE, dotImporter, type DotImportOptions } from "./importer.js";
+export { DOT_STYLE_BLOCK_ATTRIBUTE, DOT_STYLE_CAPABILITIES } from "./styles.js";

package/src/formats/dot/positions.ts

@@ -0,0 +1,77 @@
+/**
+ * How a DOT file's `pos` values are spelled, for `extractPositions()`: the node's center, y up.
+ * Graphviz layout output (the root graph has `bb`) is in points; input `pos` for neato and fdp is
+ * in inches. Each cluster's `bb` gives its container node a box.
+ */
+
+import type { GraphSnapshot } from "@graphty/graph-format";
+
+import { median } from "../../positions/convert.js";
+import type { ImporterGroupBox, ImporterPositions } from "../../positions/types.js";
+
+/** Points per inch: node `width` is in inches, laid-out coordinates in points. */
+const POINTS_PER_INCH = 72;
+
+/**
+ * The spelling of a DOT file's positions.
+ * @param snapshot - the graph the DOT importer read
+ * @returns the spelling, or null when no node has a position
+ */
+export function dotPositions(snapshot: GraphSnapshot): ImporterPositions | null {
+    if (snapshot.nodes.byRole("position") === null) {
+        return null;
+    }
+    const bb = snapshot.graph.get("bb");
+    const laidOut = bb !== null && bb.isSet(0) && boxOf(bb.value(0)) !== null;
+    const width = snapshot.nodes.get("width");
+    const widths: number[] = [];
+    for (let row = 0; width !== null && row < width.length; row++) {
+        const w = width.isSet(row) ? Number(width.value(row)) : Number.NaN;
+        if (Number.isFinite(w)) {
+            widths.push(laidOut ? w * POINTS_PER_INCH : w);
+        }
+    }
+    return {
+        units: laidOut ? "px" : "file",
+        // input inches are drawn beside the styles' point lengths at 72 points each
+        ...(laidOut ? {} : { pxPerUnit: POINTS_PER_INCH }),
+        yAxis: "up",
+        groups: clusterBoxes(snapshot),
+        medianNodeSize: median(widths),
+        ...(laidOut ? { tool: "graphviz" } : {}),
+    };
+}
+
+/**
+ * The boxes of the cluster container nodes that carry a `bb`.
+ * @param snapshot - the graph
+ * @returns one box per container, centered, y up
+ */
+function clusterBoxes(snapshot: GraphSnapshot): ImporterGroupBox[] {
+    const bb = snapshot.nodes.get("bb");
+    const out: ImporterGroupBox[] = [];
+    for (let node = 0; bb !== null && node < bb.length; node++) {
+        const box = bb.isSet(node) ? boxOf(bb.value(node)) : null;
+        if (box !== null) {
+            out.push({ node, box });
+        }
+    }
+    return out;
+}
+
+/**
+ * A Graphviz `bb` ("llx,lly,urx,ury", y up) as a centered box.
+ * @param value - the attribute value
+ * @returns the box, or null when the value is not four finite numbers
+ */
+function boxOf(value: unknown): ImporterGroupBox["box"] | null {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const parts = value.split(",").map(Number);
+    if (parts.length !== 4 || !parts.every(Number.isFinite)) {
+        return null;
+    }
+    const [llx, lly, urx, ury] = parts;
+    return { x: (llx + urx) / 2, y: (lly + ury) / 2, width: urx - llx, height: ury - lly };
+}