@rse/gradia 0.9.8 → 1.0.0

package/dst/gradia-api-type-hub.js

@@ -81,6 +81,9 @@ export const render = async (graph, config) => {
     const scale = config["size-node-height-scale"];
     /*  the fixed three-column layout assignment  */
     const colOf = (id) => id === center.id ? 1 : (inputSet.has(id) ? 0 : 2);
+    /*  determine the attachment sides of every edge (east/west),
+        derived from the column relation of its endpoint nodes  */
+    const sides = edges.map((edge) => colOf(edge.source) < colOf(edge.target) ? { s: "e", t: "w" } : { s: "w", t: "e" });
     /*  determine node box sizes from their textual content (all boxes at
         half height scale), then grow every box whose edge attachments
         exceed the configured per-side maximum, step-wise by one port
@@ -88,12 +91,10 @@ export const render = async (graph, config) => {
         attachment room without a fixed height increase  */
     const { boxW, boxH, contentH } = measureNodes(nodes, config, () => scale / 2);
     const portCnt = new Map();
-    for (const edge of edges) {
-        const sSide = colOf(edge.source) < colOf(edge.target) ? "e" : "w";
-        const tSide = sSide === "e" ? "w" : "e";
-        portCnt.set(`${sSide}:${edge.source}`, (portCnt.get(`${sSide}:${edge.source}`) ?? 0) + 1);
-        portCnt.set(`${tSide}:${edge.target}`, (portCnt.get(`${tSide}:${edge.target}`) ?? 0) + 1);
-    }
+    edges.forEach((edge, i) => {
+        portCnt.set(`${sides[i].s}:${edge.source}`, (portCnt.get(`${sides[i].s}:${edge.source}`) ?? 0) + 1);
+        portCnt.set(`${sides[i].t}:${edge.target}`, (portCnt.get(`${sides[i].t}:${edge.target}`) ?? 0) + 1);
+    });
     for (const node of nodes) {
         const cnt = Math.max(portCnt.get(`w:${node.id}`) ?? 0, portCnt.get(`e:${node.id}`) ?? 0);
         if (cnt > config["hub-node-degree-max"])
@@ -148,9 +149,6 @@ export const render = async (graph, config) => {
             return colLX[1] + colWidth[1] / 2;
     };
     const cy = (id) => nodeCY.get(id);
-    /*  determine the attachment sides of every edge (east/west),
-        derived from the column relation of its endpoint nodes  */
-    const sides = edges.map((edge) => colOf(edge.source) < colOf(edge.target) ? { s: "e", t: "w" } : { s: "w", t: "e" });
     /*  distribute the edge attachment ports along each node side  */
     const portPos = assignPorts(edges, sides, cx, cy, boxW, boxH);
     /*  assign the vertical tracks within each channel (see assignTracks

package/dst/gradia-api.js

@@ -39,7 +39,7 @@ export const diagramFormatDefault = "svg:standalone";
 export class Gradia {
     /*  the rendering configuration options and their default values
         (exposed so consumers can discover and validate the options)  */
-    static config = configDefaults;
+    static config = Object.freeze({ ...configDefaults });
     /*  parse a graph description into the graph model  */
     static parse(spec) {
         return parse(spec);
@@ -67,15 +67,31 @@ export class Gradia {
         const layout = parts === null ?
             await renderers[type](graph, config) :
             composeGroups(parts, await Promise.all(parts.map((part) => renderers[type](part.graph, config))), config);
+        /*  derive the identifier seed of the SVG document from everything
+            which determines the rendered output, so that regenerating an
+            unchanged diagram yields a byte-identical SVG (the explicitly
+            configured options enter as their sorted key list only, as
+            their values are already part of the layered configuration and
+            merely their presence decides between a hard-coded CSS value
+            and a CSS custom property lookup)  */
+        const seed = JSON.stringify({
+            type,
+            config,
+            explicit: Object.keys(explicit).sort(),
+            nodes: Array.from(graph.nodes.values()),
+            edges: graph.edges
+        });
         /*  render the laid out graph into an SVG document  */
-        const svg = renderSVG(layout, config, explicit);
-        /*  convert the SVG document into the requested output format  */
+        const svg = renderSVG(layout, config, explicit, seed);
+        /*  convert the SVG document into the requested output format
+            (the Base64 encoding uses the platform-neutral "btoa", as the
+            API is also shipped as a browser bundle without "Buffer")  */
         if (format === "svg:embedded")
             return svg.replace(/^<\?xml[^?]*\?>\n/, "");
         else if (format === "url:xml")
             return `data:image/svg+xml,${encodeURIComponent(svg)}`;
         else if (format === "url:base64")
-            return `data:image/svg+xml;base64,${Buffer.from(svg, "utf8").toString("base64")}`;
+            return `data:image/svg+xml;base64,${btoa(Array.from(new TextEncoder().encode(svg), (byte) => String.fromCharCode(byte)).join(""))}`;
         else
             return svg;
     }