@graphty/graph-io 0.3.28 → 0.3.30

package/dist/chunks/{export-CHd4tQE2.js → export-Dq4U8Ubq.js}

@@ -3257,9 +3257,6 @@ function formatF32(value) {
   }
   return String(value);
 }
-function survivesF32(value) {
-  return Number(formatF32(Math.fround(value))) === value;
-}
 function formatF64(value) {
   return Object.is(value, -0) ? "-0" : String(value);
 }
@@ -3623,56 +3620,10 @@ function checkCapabilities(snapshot, caps, options, extras = {}) {
   const note = (code, message, column = null, count = null) => {
     notes.push(Object.freeze({ code, message, column, count }));
   };
-  const mixed = countMixedEdges(snapshot);
-  if (mixed > 0 && !caps.mixedDirection) {
-    if (options.onMixedDirection === "error") {
-      note(
-        LOSS.MIXED_DIRECTION_ERROR,
-        `${mixed} undirected edge${plural(mixed)} in a directed graph, and the format holds one direction per file, so the save fails unless onMixedDirection is "directed" or "undirected"`,
-        null,
-        mixed
-      );
-    } else {
-      note(
-        LOSS.MIXED_DIRECTION,
-        `${mixed} undirected edge${plural(mixed)} in a directed graph ${agree(mixed, "is", "are")} written as ${options.onMixedDirection} (onMixedDirection), and the format holds one direction per file`,
-        null,
-        mixed
-      );
-    }
-  }
-  if (snapshot.flags.multigraph && !caps.multiEdges) {
-    const parallel = countParallelArcs(snapshot);
-    note(
-      LOSS.MULTI_EDGES,
-      `${parallel} parallel edge${plural(parallel)}; the format has no parallel edges`,
-      null,
-      parallel
-    );
-  }
-  if (snapshot.selfLoopCount > 0 && !caps.selfLoops) {
-    note(
-      LOSS.SELF_LOOPS,
-      `${snapshot.selfLoopCount} self-loop${plural(snapshot.selfLoopCount)}; the format has no self-loops`,
-      null,
-      snapshot.selfLoopCount
-    );
-  }
-  const edgeIds = snapshot.edges.byRole("id");
-  if (caps.edgeIds === "required" && edgeIds === null && snapshot.edgeCount > 0) {
-    note(
-      LOSS.EDGE_IDS_GENERATED,
-      "the format requires edge ids, and the graph has none; the edges are written with generated ids, which read back as a new edge id column",
-      null,
-      snapshot.edgeCount
-    );
-  } else if (caps.edgeIds === "none" && edgeIds !== null) {
-    note(
-      LOSS.EDGE_IDS_DROPPED,
-      `edge id column "${edgeIds.meta.name}" cannot be written`,
-      edgeIds.meta.name,
-      snapshot.edgeCount
-    );
+  const tables = extras.tables ?? ["node", "edge", "graph"];
+  const edges = tables.includes("edge");
+  if (edges) {
+    checkEdgeStructure(snapshot, caps, options, note);
   }
   const unrepresentable = countUnrepresentableIds(snapshot, caps.idCharset);
   if (unrepresentable > 0) {
@@ -3716,23 +3667,37 @@ function checkCapabilities(snapshot, caps, options, extras = {}) {
       );
     }
   }
-  checkWeights(snapshot, extras, note);
-  checkColumns(snapshot.nodes, "node", caps, extras, note);
-  checkColumns(snapshot.edges, "edge", caps, extras, note);
-  const graphColumns = snapshot.graph.names();
+  if (edges) {
+    checkWeights(snapshot, extras, note);
+  }
+  if (tables.includes("node")) {
+    checkColumns(snapshot.nodes, "node", caps, extras, note);
+  }
+  if (edges) {
+    checkColumns(snapshot.edges, "edge", caps, extras, note);
+  }
+  const graphColumns = tables.includes("graph") ? snapshot.graph.names() : [];
   if (graphColumns.length > 0) {
     if (caps.graphAttributes) {
       checkColumns(snapshot.graph, "graph", caps, extras, note);
     } else {
-      note(
-        LOSS.GRAPH_ATTRIBUTES,
-        `${graphColumns.length} graph attribute${plural(graphColumns.length)} cannot be written`,
-        null,
-        graphColumns.length
+      notes.push(
+        Object.freeze({
+          code: LOSS.GRAPH_ATTRIBUTES,
+          message: `${graphColumns.length} graph attribute${plural(graphColumns.length)} cannot be written`,
+          column: null,
+          count: graphColumns.length,
+          columns: Object.freeze([...graphColumns])
+        })
       );
     }
   }
   for (const [name, table] of snapshot.extensions) {
+    const [, kind] = name.split(":");
+    const owner = name.startsWith("temporal:") && (kind === "node" || kind === "edge") ? kind : "graph";
+    if (!tables.includes(owner)) {
+      continue;
+    }
     if (name.startsWith("temporal:")) {
       if (caps.temporal !== "dynamic-values") {
         note(
@@ -3753,6 +3718,59 @@ function checkCapabilities(snapshot, caps, options, extras = {}) {
   }
   return notes;
 }
+function checkEdgeStructure(snapshot, caps, options, note) {
+  const mixed = countMixedEdges(snapshot);
+  if (mixed > 0 && !caps.mixedDirection) {
+    if (options.onMixedDirection === "error") {
+      note(
+        LOSS.MIXED_DIRECTION_ERROR,
+        `${mixed} undirected edge${plural(mixed)} in a directed graph, and the format holds one direction per file, so the save fails unless onMixedDirection is "directed" or "undirected"`,
+        null,
+        mixed
+      );
+    } else {
+      note(
+        LOSS.MIXED_DIRECTION,
+        `${mixed} undirected edge${plural(mixed)} in a directed graph ${agree(mixed, "is", "are")} written as ${options.onMixedDirection} (onMixedDirection), and the format holds one direction per file`,
+        null,
+        mixed
+      );
+    }
+  }
+  if (snapshot.flags.multigraph && !caps.multiEdges) {
+    const parallel = countParallelArcs(snapshot);
+    note(
+      LOSS.MULTI_EDGES,
+      `${parallel} parallel edge${plural(parallel)}; the format has no parallel edges`,
+      null,
+      parallel
+    );
+  }
+  if (snapshot.selfLoopCount > 0 && !caps.selfLoops) {
+    note(
+      LOSS.SELF_LOOPS,
+      `${snapshot.selfLoopCount} self-loop${plural(snapshot.selfLoopCount)}; the format has no self-loops`,
+      null,
+      snapshot.selfLoopCount
+    );
+  }
+  const edgeIds = snapshot.edges.byRole("id");
+  if (caps.edgeIds === "required" && edgeIds === null && snapshot.edgeCount > 0) {
+    note(
+      LOSS.EDGE_IDS_GENERATED,
+      "the format requires edge ids, and the graph has none; the edges are written with generated ids, which read back as a new edge id column",
+      null,
+      snapshot.edgeCount
+    );
+  } else if (caps.edgeIds === "none" && edgeIds !== null) {
+    note(
+      LOSS.EDGE_IDS_DROPPED,
+      `edge id column "${edgeIds.meta.name}" cannot be written`,
+      edgeIds.meta.name,
+      snapshot.edgeCount
+    );
+  }
+}
 function charsetText(charset, n) {
   const are = agree(n, "is", "are");
   switch (charset) {
@@ -4174,7 +4192,7 @@ export {
   STATUS_FAILED_CODE as Z,
   STATUS_WARNING_CODE as _,
   checkCapabilities as a,
-  COLUMN_DROPPED_CODE as a$,
+  COLUMN_RENAMED_LOSS_CODE as a$,
   uniqueColumnName as a0,
   declareResolved as a1,
   JSON_NONSTANDARD_NUMBER_CODE as a2,
@@ -4194,24 +4212,24 @@ export {
   formatInteger as aG,
   canonicalId as aH,
   coerceIdText as aI,
-  survivesF32 as aJ,
-  isWeightField as aK,
-  parseWeightText as aL,
-  isAbortError as aM,
-  BAD_LINE_CODE as aN,
-  messageOf as aO,
-  describe as aP,
-  UNKNOWN_OPTION_CODE as aQ,
-  normalizeInput as aR,
-  foreignKind as aS,
-  ImportError as aT,
-  FETCH_CODE as aU,
-  EDGES_MERGED_CODE as aV,
-  SELF_LOOPS_DROPPED_CODE as aW,
-  WEIGHT_NOT_FOUND_CODE as aX,
-  lockReader as aY,
-  abortable as aZ,
-  BAD_OPTIONS_CODE as a_,
+  isWeightField as aJ,
+  parseWeightText as aK,
+  isAbortError as aL,
+  BAD_LINE_CODE as aM,
+  messageOf as aN,
+  describe as aO,
+  UNKNOWN_OPTION_CODE as aP,
+  normalizeInput as aQ,
+  foreignKind as aR,
+  ImportError as aS,
+  FETCH_CODE as aT,
+  EDGES_MERGED_CODE as aU,
+  SELF_LOOPS_DROPPED_CODE as aV,
+  WEIGHT_NOT_FOUND_CODE as aW,
+  lockReader as aX,
+  abortable as aY,
+  BAD_OPTIONS_CODE as aZ,
+  COLUMN_DROPPED_CODE as a_,
   formatF32 as aa,
   formatF64 as ab,
   DictHeuristic as ac,
@@ -4239,73 +4257,72 @@ export {
   RENAMED_CODE as ay,
   LineReader as az,
   plural as b,
-  otherFormatDialect as b$,
-  COLUMN_RENAMED_LOSS_CODE as b0,
-  CONTROL_CHARACTER_CODE as b1,
-  DEFAULT_ERROR_LIMIT as b2,
-  DIRECTED_COLUMN as b3,
-  DIRECTION_DROPPED_CODE as b4,
-  DUPLICATE_EDGE_CODE as b5,
-  EMPTY_COLUMN_DROPPED_CODE as b6,
-  EQUATION_AS_TEXT_CODE as b7,
-  FOREIGN_FORMAT_CODE as b8,
-  ID_TEXT_COLLISION_CODE as b9,
-  isNmtoken as bA,
-  mangleNmtoken as bB,
-  readText as bC,
-  refusedSave as bD,
-  countMixedEdges as bE,
-  canonicalEncoding as bF,
-  TIME_TEXT_ROLE as bG,
-  TIME_TEXT_SUFFIX as bH,
-  declareAttribute as bI,
-  overflowsToInfinity as bJ,
-  parseDeclaredTemporal as bK,
-  parseDeclaredValue as bL,
-  losesPrecision as bM,
-  parseTimeText as bN,
-  splitListText as bO,
-  timeTextCompanion as bP,
-  parseDecimalText as bQ,
-  formatTimeValue as bR,
-  mapDeclaredType as bS,
-  joinListText as bT,
-  formatTemporal as bU,
-  DICT_SAMPLE_ROWS as bV,
-  reportWeightPrecision as bW,
-  takenIn as bX,
-  declareOn as bY,
-  parseTemporal as bZ,
-  withArticle as b_,
-  INTEGRAL_F64_CODE as ba,
-  ISSUES_SUPPRESSED_CODE as bb,
-  MUTUAL_COLUMN as bc,
-  MUTUAL_EXPANDED_CODE as bd,
-  NONFINITE_AS_NULL_CODE as be,
-  NO_CAPABILITIES as bf,
-  OPTIONS_GAINED_CODE as bg,
-  PAIR_COLUMN as bh,
-  PARSE_ERROR_CODE as bi,
-  SELF_LOOP_CODE as bj,
-  STORAGE_CLASS_CODE as bk,
-  TEMPORAL_DROPPED_CODE as bl,
-  TEMPORAL_TEXT_DROPPED_CODE as bm,
-  TEXT_INFERRED_CODE as bn,
-  UNKNOWN_TYPE_CODE as bo,
-  WEIGHTS_DROPPED_CODE as bp,
-  WEIGHT_KEY_CLASH_CODE as bq,
-  coerceId as br,
-  declareCompanion as bs,
-  decodeEntryName as bt,
-  edgeWeights as bu,
-  forDecodedText as bv,
-  formatGmlReal as bw,
-  inputLength as bx,
-  isCanonicalIntegerText as by,
-  isImportInput as bz,
+  readBytes as b$,
+  CONTROL_CHARACTER_CODE as b0,
+  DEFAULT_ERROR_LIMIT as b1,
+  DIRECTED_COLUMN as b2,
+  DIRECTION_DROPPED_CODE as b3,
+  DUPLICATE_EDGE_CODE as b4,
+  EMPTY_COLUMN_DROPPED_CODE as b5,
+  EQUATION_AS_TEXT_CODE as b6,
+  FOREIGN_FORMAT_CODE as b7,
+  ID_TEXT_COLLISION_CODE as b8,
+  INTEGRAL_F64_CODE as b9,
+  mangleNmtoken as bA,
+  readText as bB,
+  refusedSave as bC,
+  countMixedEdges as bD,
+  canonicalEncoding as bE,
+  TIME_TEXT_ROLE as bF,
+  TIME_TEXT_SUFFIX as bG,
+  declareAttribute as bH,
+  overflowsToInfinity as bI,
+  parseDeclaredTemporal as bJ,
+  parseDeclaredValue as bK,
+  losesPrecision as bL,
+  parseTimeText as bM,
+  splitListText as bN,
+  timeTextCompanion as bO,
+  parseDecimalText as bP,
+  formatTimeValue as bQ,
+  mapDeclaredType as bR,
+  joinListText as bS,
+  formatTemporal as bT,
+  DICT_SAMPLE_ROWS as bU,
+  reportWeightPrecision as bV,
+  takenIn as bW,
+  declareOn as bX,
+  parseTemporal as bY,
+  withArticle as bZ,
+  otherFormatDialect as b_,
+  ISSUES_SUPPRESSED_CODE as ba,
+  MUTUAL_COLUMN as bb,
+  MUTUAL_EXPANDED_CODE as bc,
+  NONFINITE_AS_NULL_CODE as bd,
+  NO_CAPABILITIES as be,
+  OPTIONS_GAINED_CODE as bf,
+  PAIR_COLUMN as bg,
+  PARSE_ERROR_CODE as bh,
+  SELF_LOOP_CODE as bi,
+  STORAGE_CLASS_CODE as bj,
+  TEMPORAL_DROPPED_CODE as bk,
+  TEMPORAL_TEXT_DROPPED_CODE as bl,
+  TEXT_INFERRED_CODE as bm,
+  UNKNOWN_TYPE_CODE as bn,
+  WEIGHTS_DROPPED_CODE as bo,
+  WEIGHT_KEY_CLASH_CODE as bp,
+  coerceId as bq,
+  declareCompanion as br,
+  decodeEntryName as bs,
+  edgeWeights as bt,
+  forDecodedText as bu,
+  formatGmlReal as bv,
+  inputLength as bw,
+  isCanonicalIntegerText as bx,
+  isImportInput as by,
+  isNmtoken as bz,
   capabilities as c,
-  readBytes as c0,
-  elementCount as c1,
+  elementCount as c0,
   DIRECTION_REFUSED_CODE as d,
   explicitWeights as e,
   STRAY_TEXT_CODE as f,
@@ -4330,4 +4347,4 @@ export {
   INVALID_ENCODING_CODE as y,
   INVALID_UTF8_CODE as z
 };
-//# sourceMappingURL=export-CHd4tQE2.js.map
+//# sourceMappingURL=export-Dq4U8Ubq.js.map