@graphty/graph-io 0.3.40 → 0.3.42

package/src/formats/graphml/tree.ts

@@ -270,18 +270,7 @@ function writeElements(name: string, value: unknown, indent: string, out: string
         return;
     }
     const object = value as XmlTreeObject;
-    let attrs = "";
-    let text: string | null = null;
-    let hasChildren = false;
-    for (const [key, child] of Object.entries(object)) {
-        if (key === TEXT_KEY) {
-            text = scalarText(child);
-        } else if (key.startsWith(ATTRIBUTE_PREFIX)) {
-            attrs += ` ${key.slice(ATTRIBUTE_PREFIX.length)}="${escapeXmlAttribute(scalarText(child))}"`;
-        } else {
-            hasChildren = true;
-        }
-    }
+    const { attrs, text, hasChildren } = scanElement(object);
     if (!hasChildren) {
         out.push(
             text === null || text.length === 0
@@ -303,6 +292,27 @@ function writeElements(name: string, value: unknown, indent: string, out: string
     out.push(`\n${indent}</${name}>`);
 }
 
+/**
+ * Split an element object into its attribute text, its text content and whether it has children.
+ * @param object - the element object
+ * @returns the attribute text, the text content (null when absent) and the children flag
+ */
+function scanElement(object: XmlTreeObject): { attrs: string; text: string | null; hasChildren: boolean } {
+    let attrs = "";
+    let text: string | null = null;
+    let hasChildren = false;
+    for (const [key, child] of Object.entries(object)) {
+        if (key === TEXT_KEY) {
+            text = scalarText(child);
+        } else if (key.startsWith(ATTRIBUTE_PREFIX)) {
+            attrs += ` ${key.slice(ATTRIBUTE_PREFIX.length)}="${escapeXmlAttribute(scalarText(child))}"`;
+        } else {
+            hasChildren = true;
+        }
+    }
+    return { attrs, text, hasChildren };
+}
+
 /**
  * The text of a scalar tree value.
  * @param value - a string, number, boolean or null

package/src/formats/graphml/yfiles.ts

@@ -109,16 +109,7 @@ export function staleGraphicsRows(column: Column, table: Iterable<Column>, domai
     }
     let stale = 0;
     for (let r = 0; r < column.length; r++) {
-        const wants = new Set<string>();
-        for (const tree of trees) {
-            const want = graphicsValues(domain, tree.values[r]).find(([f]) => f === field);
-            if (want !== undefined) {
-                wants.add(JSON.stringify(want[1]));
-            }
-        }
-        if (wants.size === 0) {
-            wants.add(JSON.stringify(undefined));
-        }
+        const wants = wantedGraphics(trees, domain, field, r);
         const value = column.value(r);
         const have = column.meta.components > 1 && value !== undefined ? Array.from(value as ArrayLike<number>) : value;
         if (!wants.has(JSON.stringify(have))) {
@@ -128,6 +119,28 @@ export function staleGraphicsRows(column: Column, table: Iterable<Column>, domai
     return stale;
 }
 
+/**
+ * The serialized values the trees want for one row of a mapped column.
+ * @param trees - the yFiles tree columns of the table
+ * @param domain - node or edge
+ * @param field - the mapped field name
+ * @param r - the row
+ * @returns the wanted values as JSON text; just `undefined`'s when no tree wants one
+ */
+function wantedGraphics(trees: JsonColumn[], domain: "node" | "edge", field: string, r: number): Set<string> {
+    const wants = new Set<string>();
+    for (const tree of trees) {
+        const want = graphicsValues(domain, tree.values[r]).find(([f]) => f === field);
+        if (want !== undefined) {
+            wants.add(JSON.stringify(want[1]));
+        }
+    }
+    if (wants.size === 0) {
+        wants.add(JSON.stringify(undefined));
+    }
+    return wants;
+}
+
 /**
  * The mapped values of one `<data>` tree of a yFiles key: a ShapeNode's for a node, a
  * PolyLineEdge's for an edge; nothing for any other graphics (GenericNode, BezierEdge, ...).

package/src/formats/json/dialect.ts

@@ -170,6 +170,17 @@ export function sniffJsonDialect(root: unknown): JsonImportDialect | null {
     if (!isJsonObject(root)) {
         return null;
     }
+    const decided = sniffWrapperDialect(root) ?? sniffEdgelessDialect(root);
+    return decided === undefined ? sniffEdgeListDialect(root) : decided;
+}
+
+/**
+ * The dialects a top-level wrapper key settles: Cytoscape `elements`, JGF `graph.nodes` /
+ * `graph.edges`, and a `graphs[]` array (OBO Graphs when any graph looks like one, else JGF).
+ * @param root - the parsed document object
+ * @returns the dialect, or undefined when no wrapper key decides it
+ */
+function sniffWrapperDialect(root: Record<string, unknown>): JsonImportDialect | undefined {
     if (hasKey(root, "elements")) {
         return "cytoscape";
     }
@@ -180,14 +191,31 @@ export function sniffJsonDialect(root: unknown): JsonImportDialect | null {
         // any graph decides: an ontology's first graph may be an empty stub before its imports
         return root.graphs.some((g: unknown) => isJsonObject(g) && isOboGraph(g)) ? "obographs" : "jgf";
     }
-    if (!hasKey(root, "edges") && !hasKey(root, "links")) {
-        if (hasKey(root, "nodes") && hasKey(root, "adjacency")) {
-            return "adjacency";
-        }
-        if (!hasKey(root, "nodes")) {
-            return hasKey(root, "children") ? "tree" : null;
-        }
+    return undefined;
+}
+
+/**
+ * The dialect of a document with neither `edges` nor `links`: NetworkX adjacency_data (`nodes`
+ * and `adjacency`), tree_data (`children` without `nodes`), or no graph at all.
+ * @param root - the parsed document object
+ * @returns the dialect; null for no graph; undefined when the edge-list rules decide
+ */
+function sniffEdgelessDialect(root: Record<string, unknown>): JsonImportDialect | null | undefined {
+    if (hasKey(root, "edges") || hasKey(root, "links")) {
+        return undefined;
+    }
+    if (hasKey(root, "nodes")) {
+        return hasKey(root, "adjacency") ? "adjacency" : undefined;
     }
+    return hasKey(root, "children") ? "tree" : null;
+}
+
+/**
+ * The dialect of a node and edge list document: graphology, vis, d3 or NetworkX node-link.
+ * @param root - the parsed document object
+ * @returns the dialect
+ */
+function sniffEdgeListDialect(root: Record<string, unknown>): JsonImportDialect {
     const firstNode = firstJsonObject(root.nodes);
     const firstEdge = firstJsonObject(hasKey(root, "edges") ? root.edges : root.links);
     if (isJsonObject(root.options) && (hasKey(root.options, "type") || hasKey(root.options, "multi"))) {
@@ -197,25 +225,36 @@ export function sniffJsonDialect(root: unknown): JsonImportDialect | null {
     // like a graphology or vis field (`attributes`, `undirected`, `key`, `from`) must not re-route it
     const networkx =
         hasKey(root, "links") || hasKey(root, "directed") || hasKey(root, "multigraph") || hasKey(root, "graph");
-    if (!networkx && firstNode !== null && hasKey(firstNode, "key") && !hasKey(firstNode, "id")) {
+    const record = networkx ? undefined : sniffRecordDialect(firstNode, firstEdge);
+    if (record !== undefined) {
+        return record;
+    }
+    const bare = !hasKey(root, "directed") && !hasKey(root, "multigraph") && !hasKey(root, "graph");
+    return bare && hasKey(root, "links") ? "d3" : "node-link";
+}
+
+/**
+ * The graphology or vis dialect, read from the first node and edge records of a document without
+ * NetworkX's keys: graphology for a `key` node without `id`, or an edge without `from` that has
+ * `undirected` or an `attributes` record; vis for an edge with `from` and `to` but no `source`.
+ * @param firstNode - the first node record, or null
+ * @param firstEdge - the first edge record, or null
+ * @returns the dialect, or undefined when the records name neither
+ */
+function sniffRecordDialect(
+    firstNode: Record<string, unknown> | null,
+    firstEdge: Record<string, unknown> | null,
+): JsonImportDialect | undefined {
+    if (firstNode !== null && hasKey(firstNode, "key") && !hasKey(firstNode, "id")) {
         return "graphology";
     }
-    if (!networkx && firstEdge !== null && !hasKey(firstEdge, "from")) {
-        if (hasKey(firstEdge, "undirected") || isJsonObject(firstEdge.attributes)) {
-            return "graphology";
-        }
+    if (firstEdge === null) {
+        return undefined;
     }
-    if (
-        !networkx &&
-        firstEdge !== null &&
-        hasKey(firstEdge, "from") &&
-        hasKey(firstEdge, "to") &&
-        !hasKey(firstEdge, "source")
-    ) {
-        return "vis";
+    if (!hasKey(firstEdge, "from")) {
+        return hasKey(firstEdge, "undirected") || isJsonObject(firstEdge.attributes) ? "graphology" : undefined;
     }
-    const bare = !hasKey(root, "directed") && !hasKey(root, "multigraph") && !hasKey(root, "graph");
-    return bare && hasKey(root, "links") ? "d3" : "node-link";
+    return hasKey(firstEdge, "to") && !hasKey(firstEdge, "source") ? "vis" : undefined;
 }
 
 /** The node types of OBO Graphs (the OWL entity kinds). */

package/src/formats/json/exporter.ts

@@ -1609,7 +1609,6 @@ function* writeCytoscape(snapshot: GraphSnapshot, p: Plan): Generator<string, vo
     const c: Cursor = { w: new JsonWriter(resolved.indent), ids: snapshot.ids, nonfinite: { count: 0 } };
     const { w } = c;
     const parentSlots: ReadonlySet<Slot> = new Set(["parent"]);
-    const positionSlots: ReadonlySet<Slot> = new Set(["cytoscapePosition"]);
     w.open("{");
     w.key("elements");
     w.open("{");
@@ -1625,18 +1624,7 @@ function* writeCytoscape(snapshot: GraphSnapshot, p: Plan): Generator<string, vo
         writeSlots(c, p.nodes, i, parentSlots);
         writeSlots(c, p.nodes, i, ATTRIBUTE_SLOTS);
         w.close("}");
-        for (const item of p.nodes) {
-            if (positionSlots.has(item.slot) && item.column.isSet(i)) {
-                const value = item.column.value(i) as ArrayLike<number>;
-                const f32 = item.column.dtype === "f32";
-                w.key("position");
-                w.open("{");
-                w.member("x", numberText(value[0], f32, c.nonfinite));
-                // stored y-up; Cytoscape's y grows downward
-                w.member("y", numberText(flipY(value[1]), f32, c.nonfinite));
-                w.close("}");
-            }
-        }
+        writeCytoscapePosition(c, p.nodes, i);
         writeSlots(c, p.nodes, i, ELEMENT_SLOTS);
         w.close("}");
         yield w.take();
@@ -1673,18 +1661,49 @@ function* writeCytoscape(snapshot: GraphSnapshot, p: Plan): Generator<string, vo
         w.key("data");
         writeGraphObject(c, p);
     }
-    const extra = resolved.shape.cytoscape;
-    if (extra !== undefined) {
-        for (const key of Object.keys(extra)) {
-            if (key !== "elements" && key !== "data") {
-                w.member(key, valueText(extra[key], false, c.nonfinite));
-            }
-        }
-    }
+    writeCytoscapeExtra(c, resolved.shape.cytoscape);
     w.close("}");
     yield w.take();
 }
 
+/**
+ * Write a node's `position` member (Cytoscape.js), when its position is set.
+ * @param c - the cursor
+ * @param items - the node plan items
+ * @param i - the node index
+ */
+function writeCytoscapePosition(c: Cursor, items: readonly ColumnPlan[], i: number): void {
+    const { w } = c;
+    for (const item of items) {
+        if (item.slot === "cytoscapePosition" && item.column.isSet(i)) {
+            const value = item.column.value(i) as ArrayLike<number>;
+            const f32 = item.column.dtype === "f32";
+            w.key("position");
+            w.open("{");
+            w.member("x", numberText(value[0], f32, c.nonfinite));
+            // stored y-up; Cytoscape's y grows downward
+            w.member("y", numberText(flipY(value[1]), f32, c.nonfinite));
+            w.close("}");
+        }
+    }
+}
+
+/**
+ * Write the extra top-level members of a Cytoscape.js document, beyond `elements` and `data`.
+ * @param c - the cursor
+ * @param extra - the extra members, when any
+ */
+function writeCytoscapeExtra(c: Cursor, extra: Readonly<Record<string, unknown>> | undefined): void {
+    if (extra === undefined) {
+        return;
+    }
+    for (const key of Object.keys(extra)) {
+        if (key !== "elements" && key !== "data") {
+            c.w.member(key, valueText(extra[key], false, c.nonfinite));
+        }
+    }
+}
+
 /**
  * A generator of canonical `e<index>` edge ids for the edges without one (design section 4.6),
  * skipping any text a node id or an explicit edge id already uses (Cytoscape ids share one