@graphty/graph-io 0.3.2 → 0.3.4

package/dist/chunks/{importer-DkzjTvHc.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;
@@ -1366,6 +1393,8 @@ const JSON_ISSUE = Object.freeze({
   HYPEREDGE_SHAPE: "E_HYPEREDGE_SHAPE",
   /** The nodes have no id key at all; array positions became the ids. */
   POSITIONAL_NODES: "W_POSITIONAL_NODES",
+  /** A node-link / d3 top-level key the importer does not read (the other of edges / links, an unknown key); it is dropped. */
+  UNREAD_KEY: "W_JSON_UNREAD_KEY",
   /** A builder-policy option (addMissingNodes, duplicateEdges, selfLoops, weightDtype) differs from the sink's (the shared W_SINK_OPTION). */
   SINK_OPTION: SINK_OPTION_CODE,
   /** A common option the dialect has no use for (nodeIdFrom outside node-link, long, restoreMangledIds). */
@@ -1376,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
 });
@@ -1417,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") {
@@ -1989,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") {
@@ -2015,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) {
@@ -2087,6 +2230,20 @@ function importNodeLink(ctx, root, dialect) {
   const multigraph = hasKey(root, "multigraph") ? flagOf(root.multigraph, "multigraph", false, report) : null;
   ctx.setHeader(directed);
   ctx.writeGraphDict(root.graph, "graph");
+  for (const key of Object.keys(root)) {
+    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
+        }
+      );
+    }
+  }
   const nodeList = nodes ?? [];
   const edgeList = edges ?? [];
   ctx.sink.reserve(nodeList.length, edgeList.length);
@@ -2334,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) ?? [];
@@ -3006,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}`, {
@@ -3026,4 +3370,4 @@ export {
   jsonCapabilities as j,
   sniffJsonDialect as s
 };
-//# sourceMappingURL=importer-DkzjTvHc.js.map
+//# sourceMappingURL=importer-BOxwmef_.js.map