@graphty/graph-io 0.3.3 → 0.3.4

package/README.md

@@ -7,7 +7,8 @@
 
 Importers and exporters for the [@graphty/graph-format](https://www.npmjs.com/package/@graphty/graph-format)
 snapshot: GEXF, GraphML, GML, DOT (Graphviz), Pajek NET, CSV / TSV, JSON (NetworkX node-link, d3,
-JSON Graph Format, Cytoscape, graphology, vis.js) and Neo4j (`neo4j-admin import` CSV).
+JSON Graph Format, Cytoscape, graphology, vis.js; NetworkX adjacency_data and tree_data are read
+only) and Neo4j (`neo4j-admin import` CSV).
 
 Every importer streams its input into a `GraphSink` (a `GraphBuilder` or your own sink) one scalar at
 a time and reports what it could not represent instead of dropping it; every exporter says what it
@@ -195,7 +196,10 @@ losses and format rules, in addition to the table:
   a count the sink cannot reserve is fatal); `*Arcs` / `*Edges` sections give per-section
   direction; time intervals map to the spells role; vertex / line parameters are plain columns read
   through the 5.1 text grammar (`2.0` stays f64, lexical forms of a string column are kept); a
-  `.paj` project file's `*Partition` / `*Vector` sections are skipped with an issue. Nodes are
+  `.paj` project file's `*Partition` / `*Vector` objects become the node columns `partition` (i32)
+  and `vector` (f64) (a second one `partition#2`, ...; their Pajek names in
+  `meta.extra.pajek.objects`), and other project sections (`*Events`, ...) are skipped with a
+  warning; a two-mode `*Vertices N N1` reads its `*Matrix` as N1 rows of N - N1 columns. Nodes are
   always written 1..N (`W_ID_RENUMBERED`: the id text is kept as the label of a node without a
   label value, a node with one loses its id; `W_PAJEK_LABEL_GAINED` when a line's parameters force
   a label); `sanitizeIds: "mangle"` also writes every renumbered vertex's original id as a
@@ -220,10 +224,19 @@ losses and format rules, in addition to the table:
   dialect has no slot for. Edge ids exist in JGF, Cytoscape, graphology and vis only; positions in
   Cytoscape only. A repeated node id is merged with `W_DUPLICATE_NODE`, a repeated edge id skipped
   with `E_DUPLICATE_EDGE_ID`; an out-of-range d3 index link is `E_BAD_INDEX`. Non-finite numbers
-  are written as `null` and reported.
+  are written as `null` and reported. NetworkX `adjacency_data` (`nodes` plus an `adjacency` list
+  per node; an undirected file lists each edge from both ends and it is read once) and `tree_data`
+  (nested `id` / `children`, read as a directed tree) are read but not written: a re-export writes
+  node-link. The bare `NaN`, `Infinity` and `-Infinity` that Python's json module writes are read as
+  numbers (`W_JSON_NONSTANDARD_NUMBER`), and an integer literal beyond 2^53 keeps its exact digits as
+  a string (`W_JSON_BIG_INTEGER`), so two large ids never round to one; the exporter writes an
+  integral number that large in exponent form (`1e+20`) so it re-imports as a number.
 - **Neo4j**: `neo4j-admin import` headers (`:ID`, `:LABEL`, `:START_ID`, `:END_ID`, `:TYPE`, typed
   properties, id spaces, arrays); one file may hold several sections; a `weight` property becomes
-  THE weight; a quoted empty `:ID` is the id `""`. Everything is directed (an undirected snapshot,
+  THE weight; a quoted empty `:ID` is the id `""`. A node of an id space (`:ID(Product)`) is stored
+  under the string id `Product:1`, with its id text in the `originalId` column and its space in
+  `idSpace`, so the same id in two spaces stays two nodes; `:START_ID(Space)` / `:END_ID(Space)`
+  resolve inside their space, and the exporter writes the id text back. Everything is directed (an undirected snapshot,
   or the folded pairs of a mixed one under `onMixedDirection: "directed"` / `"undirected"`, is
   written with a `W_NEO4J_UNDIRECTED_AS_DIRECTED` note); `.text` companions keep the source text of
   temporal values whose canonical form differs; a dict column reads back as string and a position

package/dist/chunks/{importer-BELrICWM.js → importer-BOxwmef_.js}

@@ -8,6 +8,11 @@ const JSON_DIALECTS = Object.freeze([
   "graphology",
   "vis"
 ]);
+const JSON_IMPORT_DIALECTS = Object.freeze([
+  ...JSON_DIALECTS,
+  "adjacency",
+  "tree"
+]);
 const META_KEY = "json";
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -18,6 +23,9 @@ function hasKey(record, key) {
 function isJsonDialect(value) {
   return typeof value === "string" && JSON_DIALECTS.includes(value);
 }
+function isJsonImportDialect(value) {
+  return typeof value === "string" && JSON_IMPORT_DIALECTS.includes(value);
+}
 function sniffJsonDialect(root) {
   if (Array.isArray(root)) {
     const first = firstJsonObject(root);
@@ -35,8 +43,13 @@ function sniffJsonDialect(root) {
   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);
@@ -91,7 +104,10 @@ const DIALECT_DEFAULT_DIRECTED = Object.freeze({
   jgf: true,
   cytoscape: true,
   graphology: true,
-  vis: false
+  vis: false,
+  // networkx adjacency_data declares `directed`; tree_graph always builds a DiGraph
+  adjacency: false,
+  tree: true
 });
 const JSON_DTYPES = Object.freeze(["f64", "i32", "bool", "string"]);
 const COMMON = {
@@ -290,10 +306,17 @@ function numberText(value, f32, nonfinite) {
     nonfinite.count++;
     return "null";
   }
-  if (f32) {
-    return formatF32(value);
+  return exponentIfUnsafe(f32 ? formatF32(value) : formatF64(value));
+}
+function exponentIfUnsafe(text) {
+  const match = /^(-?)([0-9]{16,})$/.exec(text);
+  if (match === null || Number.isSafeInteger(Number(text))) {
+    return text;
   }
-  return formatF64(value);
+  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}`;
 }
 function valueText(value, f32, nonfinite) {
   switch (typeof value) {
@@ -325,7 +348,7 @@ function cellText(column, row, ids, nonfinite) {
     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":
@@ -716,7 +739,8 @@ function planWeights(ctx, edges) {
     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);
   };
 }
 function planDirection(ctx) {
@@ -890,7 +914,10 @@ function anySet(plans, row, slots) {
   return plans.some((item) => slots.has(item.slot) && item.column.isSet(row));
 }
 function idText(id) {
-  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);
 }
 function edgeIdText(p, e, c) {
   const column = p.edgeIds;
@@ -1378,6 +1405,10 @@ const JSON_ISSUE = Object.freeze({
   INVALID_ENCODING: INVALID_ENCODING_CODE,
   /** Bytes that are not UTF-8 and declare no encoding were read as windows-1252. */
   ENCODING_FALLBACK: ENCODING_FALLBACK_CODE,
+  /** The document uses the non-standard tokens NaN / Infinity / -Infinity (Python's json writes them); read as numbers. */
+  NONSTANDARD_NUMBER: "W_JSON_NONSTANDARD_NUMBER",
+  /** Integer literals beyond 2^53 were read as their exact digits (strings), not as rounded numbers. */
+  BIG_INTEGER: "W_JSON_BIG_INTEGER",
   /** A declared encoding the platform cannot decode was ignored. */
   UNKNOWN_ENCODING: UNKNOWN_ENCODING_CODE
 });
@@ -1419,8 +1450,8 @@ const VIS_TARGET_KEYS = Object.freeze(["to"]);
 function resolveJsonOptions(options) {
   const o = options ?? {};
   const dialect = o.dialect ?? "auto";
-  if (dialect !== "auto" && !isJsonDialect(dialect)) {
-    throw unsupportedOption("dialect", dialect, [...JSON_DIALECTS, "auto"]);
+  if (dialect !== "auto" && !isJsonImportDialect(dialect)) {
+    throw unsupportedOption("dialect", dialect, [...JSON_IMPORT_DIALECTS, "auto"]);
   }
   const indexLinks = o.indexLinks ?? "auto";
   if (indexLinks !== "auto" && typeof indexLinks !== "boolean") {
@@ -1991,12 +2022,122 @@ function parseDocument(text, report) {
   if (text.trim().length === 0) {
     report.fail(JSON_ISSUE.EMPTY_INPUT, "the input is empty");
   }
+  let root;
+  let syntaxError = null;
   try {
-    return JSON.parse(text);
+    root = JSON.parse(text);
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return report.fail(JSON_ISSUE.SYNTAX, `invalid JSON: ${message}`);
+    syntaxError = err instanceof Error ? err.message : String(err);
+  }
+  if (syntaxError === null && !MAYBE_UNSAFE_INTEGER.test(text)) {
+    return root;
+  }
+  const scan = rewriteNumbers(text);
+  if (scan.tokens.size > 0 || scan.bigIntegers.length > 0) {
+    try {
+      root = JSON.parse(scan.text, scan.tokens.size > 0 ? reviveNonstandard : void 0);
+      syntaxError = null;
+    } catch {
+    }
+  }
+  if (syntaxError !== null) {
+    return report.fail(JSON_ISSUE.SYNTAX, `invalid JSON: ${syntaxError}`);
+  }
+  if (scan.tokens.size > 0) {
+    report.warning(
+      "coercion",
+      JSON_ISSUE.NONSTANDARD_NUMBER,
+      `the document uses the non-standard token(s) ${[...scan.tokens].join(", ")}, which strict JSON does not allow; read as numbers`
+    );
   }
+  if (scan.bigIntegers.length > 0) {
+    const shown = scan.bigIntegers.slice(0, BIG_INTEGERS_SHOWN).join(", ");
+    const more = scan.bigIntegers.length - BIG_INTEGERS_SHOWN;
+    report.warning(
+      "precision",
+      JSON_ISSUE.BIG_INTEGER,
+      `${scan.bigIntegers.length} integer(s) beyond 2^53 kept as text so no digit is lost: ${shown}${more > 0 ? ` and ${more} more` : ""}`
+    );
+  }
+  return root;
+}
+const MAYBE_UNSAFE_INTEGER = new RegExp("(?<![0-9.])[0-9]{16}");
+const BIG_INTEGERS_SHOWN = 10;
+const NONSTANDARD_SENTINEL = `${String.fromCharCode(0)}graph-io:`;
+const NONSTANDARD_TOKENS = [
+  ["-Infinity", -Infinity],
+  ["Infinity", Infinity],
+  ["NaN", NaN]
+];
+const INTEGER_LITERAL = /^-?(0|[1-9][0-9]*)$/;
+function rewriteNumbers(text) {
+  const parts = [];
+  const tokens = /* @__PURE__ */ new Set();
+  const bigIntegers = [];
+  const arrays = [];
+  let expectValue = true;
+  let copied = 0;
+  let i = 0;
+  const n = text.length;
+  while (i < n) {
+    const ch = text[i];
+    if (ch === '"') {
+      i++;
+      while (i < n && text[i] !== '"') {
+        i += text[i] === "\\" ? 2 : 1;
+      }
+      i++;
+      expectValue = false;
+      continue;
+    }
+    if (ch === "{" || ch === "[") {
+      arrays.push(ch === "[");
+      expectValue = ch === "[";
+    } else if (ch === "}" || ch === "]") {
+      arrays.pop();
+      expectValue = false;
+    } else if (ch === ":") {
+      expectValue = true;
+    } else if (ch === ",") {
+      expectValue = arrays.length > 0 && arrays[arrays.length - 1];
+    } else if (expectValue && ch !== " " && ch !== "	" && ch !== "\n" && ch !== "\r") {
+      expectValue = false;
+      const token = NONSTANDARD_TOKENS.find(([word]) => text.startsWith(word, i));
+      let end = i;
+      let replacement = null;
+      if (token !== void 0) {
+        end = i + token[0].length;
+        tokens.add(token[0]);
+        replacement = JSON.stringify(`${NONSTANDARD_SENTINEL}${token[0]}`);
+      } else if (ch === "-" || ch >= "0" && ch <= "9") {
+        end = i + 1;
+        while (end < n && "0123456789+-.eE".includes(text[end])) {
+          end++;
+        }
+        const literal = text.slice(i, end);
+        if (INTEGER_LITERAL.test(literal) && !Number.isSafeInteger(Number(literal))) {
+          bigIntegers.push(literal);
+          replacement = `"${literal}"`;
+        }
+      }
+      if (replacement !== null) {
+        parts.push(text.slice(copied, i), replacement);
+        copied = end;
+      }
+      i = Math.max(end, i + 1);
+      continue;
+    }
+    i++;
+  }
+  parts.push(text.slice(copied));
+  return { text: parts.join(""), tokens, bigIntegers };
+}
+function reviveNonstandard(_key, value) {
+  if (typeof value === "string" && value.startsWith(NONSTANDARD_SENTINEL)) {
+    const found = NONSTANDARD_TOKENS.find(([word]) => word === value.slice(NONSTANDARD_SENTINEL.length));
+    return found === void 0 ? value : found[1];
+  }
+  return value;
 }
 function detectDialect(root, forced, report) {
   if (forced !== "auto") {
@@ -2017,7 +2158,7 @@ function detectDialect(root, forced, report) {
   }
   return report.fail(
     JSON_ISSUE.DIALECT,
-    "no known dialect: expected nodes / links / edges (node-link), elements (Cytoscape) or graph (JGF)"
+    "no known dialect: expected nodes / links / edges (node-link), nodes / adjacency (adjacency), children (tree), elements (Cytoscape) or graph (JGF)"
   );
 }
 function arraySection(value, what, report) {
@@ -2093,9 +2234,14 @@ function importNodeLink(ctx, root, dialect) {
     if (key !== "nodes" && key !== edgesKey && key !== "directed" && key !== "multigraph" && key !== "graph") {
       const value = root[key];
       const what = Array.isArray(value) ? `${String(value.length)} ${value.length === 1 ? "entry" : "entries"}` : describe(value);
-      report.warning("unsupported", JSON_ISSUE.UNREAD_KEY, `top-level key ${key} (${what}) is not read; dropped`, {
-        element: key
-      });
+      report.warning(
+        "unsupported",
+        JSON_ISSUE.UNREAD_KEY,
+        `top-level key ${key} (${what}) is not read; dropped`,
+        {
+          element: key
+        }
+      );
     }
   }
   const nodeList = nodes ?? [];
@@ -2345,6 +2491,187 @@ function importVis(ctx, root) {
     ctx.weightOriginPatch()
   );
 }
+function importAdjacency(ctx, root) {
+  const { report } = ctx;
+  const nodes = arraySection(root.nodes, "nodes", report) ?? [];
+  const adjacency = arraySection(root.adjacency, "adjacency", report);
+  if (adjacency === null) {
+    report.error(
+      "missing-value",
+      JSON_ISSUE.MISSING_SECTION,
+      "the document has no adjacency array; the graph has no edges",
+      {
+        element: "adjacency"
+      }
+    );
+  }
+  const directed = flagOf(root.directed, "directed", ctx.defaultDirected("adjacency"), report);
+  const multigraph = hasKey(root, "multigraph") ? flagOf(root.multigraph, "multigraph", false, report) : null;
+  ctx.setHeader(directed);
+  ctx.writeGraphDict(isPairList(root.graph) ? Object.fromEntries(root.graph) : root.graph, "graph");
+  for (const key of Object.keys(root)) {
+    if (key !== "nodes" && key !== "adjacency" && key !== "directed" && key !== "multigraph" && key !== "graph") {
+      report.warning(
+        "unsupported",
+        JSON_ISSUE.UNREAD_KEY,
+        `top-level key ${key} (${describe(root[key])}) is not read; dropped`,
+        {
+          element: key
+        }
+      );
+    }
+  }
+  const lists = adjacency ?? [];
+  ctx.sink.reserve(
+    nodes.length,
+    lists.reduce((sum, list) => sum + (Array.isArray(list) ? list.length : 0), 0)
+  );
+  const idKey = ctx.json.nodeIdKey ?? "id";
+  ctx.reportNodeIdFrom("adjacency", `the ${JSON.stringify(idKey)} key`);
+  const owners = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const element = `nodes[${i}]`;
+    const record = nodes[i];
+    let pushed = null;
+    if (!isJsonObject(record)) {
+      ctx.badElement("node", element);
+    } else {
+      const id = ctx.coerceId(hasKey(record, idKey) ? record[idKey] : void 0, element);
+      if (id === null) {
+        ctx.countSkipped("node");
+      } else {
+        const index = ctx.pushNode(id, element);
+        if (index >= 0) {
+          pushed = id;
+          writeFlat(ctx, ctx.nodes, index, record, id, (key) => key !== idKey);
+        }
+      }
+    }
+    owners.push(pushed);
+  }
+  throwIfAborted(ctx.options.signal);
+  const kind = ctx.uniformKind();
+  const { weightFrom } = ctx.options;
+  const pending = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lists.length; i++) {
+    const element = `adjacency[${i}]`;
+    const list = lists[i];
+    if (!Array.isArray(list)) {
+      report.error("validation-error", JSON_ISSUE.BAD_ELEMENT, `${element} is not an array`, { element });
+      continue;
+    }
+    const source = i < owners.length ? owners[i] : null;
+    if (source === null) {
+      const why = i < nodes.length ? `nodes[${i}] was skipped` : `there is no nodes[${i}]`;
+      report.error(
+        "missing-value",
+        JSON_ISSUE.BAD_INDEX,
+        `${element}: ${why}; its ${list.length} edge(s) are skipped`,
+        {
+          element
+        }
+      );
+      report.counts.skippedEdges += list.length;
+      continue;
+    }
+    for (let j = 0; j < list.length; j++) {
+      const entry = `${element}[${j}]`;
+      const record = list[j];
+      if (!isJsonObject(record)) {
+        ctx.badElement("edge", entry);
+        continue;
+      }
+      if (!hasKey(record, idKey)) {
+        ctx.missingEndpoint(entry, idKey);
+        continue;
+      }
+      try {
+        const target = ctx.coerceId(record[idKey], `${entry}.${idKey}`);
+        if (target === null) {
+          ctx.countSkipped("edge");
+          continue;
+        }
+        if (!directed && isMirroredEntry(pending, source, target, record.key)) {
+          continue;
+        }
+        const edge = ctx.pushEdge(source, target, kind, ctx.weightOf(record), entry);
+        for (const key of Object.keys(record)) {
+          if (key !== idKey && key !== weightFrom) {
+            ctx.edges.write(edge, key, record[key], SUFFIX.data);
+          }
+        }
+      } catch (err) {
+        ctx.skip(err, "edge", entry);
+      }
+    }
+  }
+  ctx.setMeta({}, { declaredMultigraph: multigraph, ...ctx.weightOriginPatch() });
+}
+function isMirroredEntry(pending, source, target, key) {
+  const a = JSON.stringify(source);
+  const b = JSON.stringify(target);
+  if (a === b) {
+    return false;
+  }
+  const k = JSON.stringify(key ?? null);
+  const mirror = `${b} ${a} ${k}`;
+  const waiting = pending.get(mirror) ?? 0;
+  if (waiting > 0) {
+    pending.set(mirror, waiting - 1);
+    return true;
+  }
+  const own = `${a} ${b} ${k}`;
+  pending.set(own, (pending.get(own) ?? 0) + 1);
+  return false;
+}
+function isPairList(value) {
+  return Array.isArray(value) && value.every((p) => Array.isArray(p) && p.length === 2 && typeof p[0] === "string");
+}
+function importTree(ctx, root) {
+  const idKey = ctx.json.nodeIdKey ?? "id";
+  ctx.setHeader(ctx.defaultDirected("tree"));
+  ctx.reportNodeIdFrom("tree", `the ${JSON.stringify(idKey)} key`);
+  const kind = ctx.uniformKind();
+  const stack = [
+    { record: root, element: "root", parent: null }
+  ];
+  for (let item = stack.pop(); item !== void 0; item = stack.pop()) {
+    const { record, element, parent } = item;
+    if (!isJsonObject(record)) {
+      ctx.badElement("node", element);
+      continue;
+    }
+    let id = ctx.coerceId(hasKey(record, idKey) ? record[idKey] : void 0, element);
+    if (id === null) {
+      ctx.countSkipped("node");
+    } else if (ctx.pushNode(id, element) < 0) {
+      id = null;
+    } else {
+      writeFlat(ctx, ctx.nodes, ctx.sink.indexOf(id), record, id, (key) => key !== idKey && key !== "children");
+      if (parent !== null) {
+        try {
+          ctx.pushEdge(parent, id, kind, void 0, element);
+        } catch (err) {
+          ctx.skip(err, "edge", element);
+        }
+      }
+    }
+    const { children } = record;
+    if (Array.isArray(children)) {
+      for (let k = children.length - 1; k >= 0; k--) {
+        stack.push({ record: children[k], element: `${element}.children[${k}]`, parent: id });
+      }
+    } else if (children !== void 0 && children !== null) {
+      ctx.report.error(
+        "validation-error",
+        JSON_ISSUE.BAD_VALUE,
+        `${element}: children must be an array, found ${describe(children)}`,
+        { element }
+      );
+    }
+  }
+  ctx.setMeta({});
+}
 function importGraphology(ctx, root) {
   const { report } = ctx;
   const nodes = arraySection(root.nodes, "nodes", report) ?? [];
@@ -3017,6 +3344,12 @@ function readGraph(root, dialect, sink, report, resolved, json, options) {
     case "vis":
       importVis(ctx, doc);
       break;
+    case "adjacency":
+      importAdjacency(ctx, doc);
+      break;
+    case "tree":
+      importTree(ctx, doc);
+      break;
     default: {
       const name = dialect;
       throw new GraphFormatError("E_UNSUPPORTED", `unknown dialect ${name}`, {
@@ -3037,4 +3370,4 @@ export {
   jsonCapabilities as j,
   sniffJsonDialect as s
 };
-//# sourceMappingURL=importer-BELrICWM.js.map
+//# sourceMappingURL=importer-BOxwmef_.js.map