@graphty/graph-io 0.3.3 → 0.3.4

package/src/formats/json/dialect.ts

@@ -9,7 +9,8 @@
  * JSON Graph Format v2 (`graph.nodes` keyed by id, per-edge `directed`, hyperedges), Cytoscape.js
  * elements (`data.id` / `data.source` / `data.target`, `position`, `classes`, `data.parent`),
  * graphology serialisation (`key` / `attributes`, `undirected` edges, `options.type` / `multi`) and
- * vis.js (`from` / `to`).
+ * vis.js (`from` / `to`); read only: NetworkX adjacency_data (`nodes` + `adjacency`) and tree_data
+ * (nested `id` / `children`).
  */
 
 import { type GraphMeta } from "@graphty/graph-format";
@@ -30,6 +31,20 @@ export const JSON_DIALECTS: readonly JsonDialect[] = Object.freeze([
     "vis",
 ]);
 
+/**
+ * The dialects the importer reads: every JsonDialect plus two it only reads, NetworkX
+ * adjacency_data (`nodes` plus one neighbour list per node under `adjacency`) and tree_data (a
+ * nested `id` / `children` record). The exporter writes neither; write node-link instead.
+ */
+export type JsonImportDialect = JsonDialect | "adjacency" | "tree";
+
+/** Every dialect the importer reads, for option checking and messages. */
+export const JSON_IMPORT_DIALECTS: readonly JsonImportDialect[] = Object.freeze([
+    ...JSON_DIALECTS,
+    "adjacency",
+    "tree",
+]);
+
 /** The key under `meta.extra` that holds the shape record (design section 8.5). */
 export const META_KEY = "json";
 
@@ -90,17 +105,28 @@ export function isJsonDialect(value: unknown): value is JsonDialect {
     return typeof value === "string" && (JSON_DIALECTS as readonly string[]).includes(value);
 }
 
+/**
+ * Whether a text names a dialect the importer reads.
+ * @param value - any value
+ * @returns true for one of JSON_IMPORT_DIALECTS
+ */
+export function isJsonImportDialect(value: unknown): value is JsonImportDialect {
+    return typeof value === "string" && (JSON_IMPORT_DIALECTS as readonly string[]).includes(value);
+}
+
 /**
  * The dialect of a parsed JSON document, by the shape rules of design section 8.2 (Cytoscape:
  * `elements` or a top-level array of `{ data }` elements; JGF: `graph.nodes` / `graph.edges` or
  * `graphs[]`; graphology: `options.type` / `options.multi`, `key` nodes without `id`, edges with
  * `undirected` or an `attributes` record; vis: edges with `from` / `to`; d3: `links` without
- * `directed` / `multigraph` / `graph`; else node-link). Pure: the importer wraps it with its issue
+ * `directed` / `multigraph` / `graph`; NetworkX adjacency_data: `nodes` and `adjacency` without
+ * `links` / `edges`; NetworkX tree_data: `children` without `nodes` / `links` / `edges`; else
+ * node-link). Pure: the importer wraps it with its issue
  * codes, the registry's sniff() uses it on a head that parses as a whole document.
  * @param root - the parsed document
  * @returns the dialect, or null when the document is not a graph document in any dialect
  */
-export function sniffJsonDialect(root: unknown): JsonDialect | null {
+export function sniffJsonDialect(root: unknown): JsonImportDialect | null {
     if (Array.isArray(root)) {
         const first = firstJsonObject(root);
         return root.length === 0 || (first !== null && isJsonObject(first.data)) ? "cytoscape" : null;
@@ -117,8 +143,13 @@ export function sniffJsonDialect(root: unknown): JsonDialect | null {
     if (Array.isArray(root.graphs)) {
         return "jgf";
     }
-    if (!hasKey(root, "nodes") && !hasKey(root, "edges") && !hasKey(root, "links")) {
-        return null;
+    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;
+        }
     }
     const firstNode = firstJsonObject(root.nodes);
     const firstEdge = firstJsonObject(hasKey(root, "edges") ? root.edges : root.links);
@@ -182,13 +213,16 @@ export function shapeMetaOf(meta: GraphMeta): JsonShapeMeta {
 }
 
 /** The direction a dialect assumes when the file declares none (design section 8.4, `defaultDirected`). */
-export const DIALECT_DEFAULT_DIRECTED: Readonly<Record<JsonDialect, boolean>> = Object.freeze({
+export const DIALECT_DEFAULT_DIRECTED: Readonly<Record<JsonImportDialect, boolean>> = Object.freeze({
     "node-link": false,
     d3: false,
     jgf: true,
     cytoscape: true,
     graphology: true,
     vis: false,
+    // networkx adjacency_data declares `directed`; tree_graph always builds a DiGraph
+    adjacency: false,
+    tree: true,
 });
 
 /**

package/src/formats/json/exporter.ts

@@ -280,11 +280,26 @@ function numberText(value: number, f32: boolean, nonfinite: Counter): string {
         nonfinite.count++;
         return "null";
     }
-    if (f32) {
-        return formatF32(value);
-    }
     // -0 is a JSON number too ("-0"); JSON.parse reads it back as -0
-    return formatF64(value);
+    return exponentIfUnsafe(f32 ? formatF32(value) : formatF64(value));
+}
+
+/**
+ * An integer text beyond 2^53 in exponent form (`100000000000000000000` -> `1e+20`, the same
+ * digits): the importer reads an integer literal that large as its exact digits (a string), so
+ * a number must not be written as one.
+ * @param text - the shortest decimal text of a finite number
+ * @returns the text, or its exponent form for an integer literal of 16 or more digits
+ */
+function exponentIfUnsafe(text: string): string {
+    const match = /^(-?)([0-9]{16,})$/.exec(text);
+    if (match === null || Number.isSafeInteger(Number(text))) {
+        return text;
+    }
+    const [, sign, digits] = match;
+    const mantissa = digits.replace(/0+$/, "");
+    const fraction = mantissa.length > 1 ? `.${mantissa.slice(1)}` : "";
+    return `${sign}${mantissa[0]}${fraction}e+${digits.length - 1}`;
 }
 
 /**
@@ -315,6 +330,8 @@ function valueText(value: unknown, f32: boolean, nonfinite: Counter): string {
         const items = Array.from(value as ArrayLike<unknown>, (item) => valueText(item, f32, nonfinite));
         return `[${items.join(",")}]`;
     }
+    // ponytail: numbers nested in a json object are written by JSON.stringify, so an integral one
+    // beyond 2^53 re-imports as its digit text; walk the object here if that ever matters
     const text = JSON.stringify(value);
     return text === undefined ? "null" : text;
 }
@@ -336,7 +353,7 @@ function cellText(column: Column, row: number, ids: GraphSnapshot["ids"], nonfin
         case "u32":
             if (column.meta.refersTo === "node" && column.meta.components === 1) {
                 const index = column.data[row];
-                return index === INVALID_INDEX ? "null" : JSON.stringify(ids.idOf(index));
+                return index === INVALID_INDEX ? "null" : idText(ids.idOf(index));
             }
             return valueText(column.value(row), false, nonfinite);
         case "f32":
@@ -839,7 +856,8 @@ function planWeights(ctx: PlanContext, edges: readonly ColumnPlan[]): (e: number
         if (!weights.isExplicit(e)) {
             return null;
         }
-        return Number.isFinite(weights.value(e)) ? weights.text(e) : "null";
+        const text = Number.isFinite(weights.value(e)) ? weights.text(e) : "null";
+        return text === null ? null : exponentIfUnsafe(text);
     };
 }
 
@@ -1093,7 +1111,10 @@ function anySet(plans: readonly ColumnPlan[], row: number, slots: ReadonlySet<Sl
  * @returns the text
  */
 function idText(id: NodeId): string {
-    return typeof id === "number" && Object.is(id, -0) ? "0" : JSON.stringify(id);
+    if (typeof id === "number") {
+        return Object.is(id, -0) ? "0" : exponentIfUnsafe(String(id));
+    }
+    return JSON.stringify(id);
 }
 
 /**