@graphty/graph-io 0.2.4 → 0.3.0

package/dist/graph-io.js

@@ -1,25 +1,25 @@
-import { I as ImportReportBuilder, a as throwIfAborted } from "./chunks/writer-DxSKC7TL.js";
-import { B, b, C, c, d, D, e, f, g, h, i, j, k, l, E, m, H, n, o, p, q, r, s, u, L, v, M, w, x, y, z, A, F, N, G, O, J, P, K, Q, R, S, T, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, as, at, au, av, aw, ax, ay, az, aA, aB, aC, aD, t, aE } from "./chunks/writer-DxSKC7TL.js";
+import { I as ImportReportBuilder, a as throwIfAborted } from "./chunks/writer-BdMak4_J.js";
+import { B, b, C, c, d, D, e, f, g, h, i, j, k, l, E, m, n, H, o, p, q, r, s, u, v, w, L, x, M, y, z, A, F, G, J, N, K, O, P, Q, R, S, T, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, as, at, au, av, aw, ax, ay, az, aA, aB, aC, aD, aE, aF, aG, t, aH } from "./chunks/writer-BdMak4_J.js";
 import { C as C2, c as c2, a } from "./chunks/children-CL3Cy0ez.js";
-import { GraphBuilder, GraphFormatError } from "@graphty/graph-format";
+import { GraphFormatError, GraphBuilder } from "@graphty/graph-format";
 import { csvImporter, csvExporter } from "./csv.js";
 import { CSV_CAPABILITIES, CSV_ISSUE, CSV_LOSS } from "./csv.js";
-import { b as dotImporter, d as dotExporter } from "./chunks/importer-DbnGYr3_.js";
-import { D as D2, a as a10 } from "./chunks/importer-DbnGYr3_.js";
+import { b as dotImporter, d as dotExporter } from "./chunks/importer-C6QcIRIb.js";
+import { D as D2, a as a10 } from "./chunks/importer-C6QcIRIb.js";
 import { gexfImporter, gexfExporter } from "./gexf.js";
 import { GEXF_1_2_CAPABILITIES, GEXF_ISSUE, GEXF_LOSS } from "./gexf.js";
 import { gmlImporter, gmlExporter } from "./gml.js";
 import { GML_ISSUE, GML_LOSS } from "./gml.js";
-import { b as graphmlImporter, g as graphmlExporter } from "./chunks/importer-GozH8DkN.js";
-import { G as G2, a as a11 } from "./chunks/importer-GozH8DkN.js";
-import { s as sniffJsonDialect, e as jsonImporter, c as jsonExporter } from "./chunks/importer-CQnJuWJw.js";
-import { J as J2, a as a12, b as b2, d as d2, j as j2 } from "./chunks/importer-CQnJuWJw.js";
+import { b as graphmlImporter, g as graphmlExporter } from "./chunks/importer-DbMrAR_w.js";
+import { G as G2, a as a11 } from "./chunks/importer-DbMrAR_w.js";
+import { s as sniffJsonDialect, e as jsonImporter, c as jsonExporter } from "./chunks/importer-DkzjTvHc.js";
+import { J as J2, a as a12, b as b2, d as d2, j as j2 } from "./chunks/importer-DkzjTvHc.js";
 import { neo4jImporter, neo4jExporter } from "./neo4j.js";
 import { ID_SPACE_COLUMN, LABELS_COLUMN, NEO4J_CAPABILITIES, NEO4J_ISSUE, NEO4J_LOSS, TYPE_COLUMN } from "./neo4j.js";
-import { b as pajekImporter, p as pajekExporter } from "./chunks/importer-CpCpfbxr.js";
-import { P as P2, a as a13 } from "./chunks/importer-CpCpfbxr.js";
-import { T as T2, W as W2, i as i2, a as a14, p as p2 } from "./chunks/text-CajMdVFy.js";
-import { X as X2, a as a15, h as h2, t as t2, x as x2 } from "./chunks/escape-DyI8JofU.js";
+import { b as pajekImporter, p as pajekExporter } from "./chunks/importer-D5pAsweZ.js";
+import { P as P2, a as a13 } from "./chunks/importer-D5pAsweZ.js";
+import { T as T2, W as W2, i as i2, a as a14, p as p2 } from "./chunks/text-Dr0Ifpag.js";
+import { X as X2, a as a15, h as h2, t as t2, x as x2 } from "./chunks/escape-CKied3Ri.js";
 const GRAPH_FORMATS = Object.freeze([
   "json",
   "graphml",
@@ -47,6 +47,10 @@ function headBytes(head) {
   if (typeof head === "string") {
     return new TextEncoder().encode(head.slice(0, SNIFF_HEAD_BYTES)).subarray(0, SNIFF_HEAD_BYTES);
   }
+  if (head.byteLength >= 2 && (head[0] === 255 && head[1] === 254 || head[0] === 254 && head[1] === 255)) {
+    const encoding = head[0] === 255 ? "utf-16le" : "utf-16be";
+    return headBytes(new TextDecoder(encoding).decode(head.subarray(0, SNIFF_HEAD_BYTES)));
+  }
   return head.byteLength > SNIFF_HEAD_BYTES ? head.subarray(0, SNIFF_HEAD_BYTES) : head;
 }
 function rankFormats(hints, importers) {
@@ -71,7 +75,7 @@ function rankFormats(hints, importers) {
       continue;
     }
     const dialect = importer.format === "json" && head !== null ? sniffJsonDialectHead(head) : null;
-    const result = Object.freeze({
+    const result2 = Object.freeze({
       format: importer.format,
       confidence: Math.min(1, confidence),
       content,
@@ -79,7 +83,7 @@ function rankFormats(hints, importers) {
       mimeType: mimeMatch,
       dialect
     });
-    candidates.push({ result, rank: rank++ });
+    candidates.push({ result: result2, rank: rank++ });
   }
   candidates.sort((a16, b3) => b3.result.confidence - a16.result.confidence || a16.rank - b3.rank);
   return candidates.map((c3) => c3.result);
@@ -370,56 +374,82 @@ class FormatRegistry {
    * own a sink). The format is the one named in the options, else sniffed from the filename,
    * the MIME type and the first bytes of the content; the builder is seeded from the common
    * options with `directed: true` as a placeholder that the importer overrides from the file.
+   * An input holding several graphs yields the first, with a warning naming how many were
+   * skipped; importAllGraphs() returns every one.
    * @param input - the text, bytes, stream or chunks to read
    * @param options - the format, hints, common and format-specific import options
    * @returns the snapshot, the import report and the freeze report
    */
   async importGraph(input, options = {}) {
-    const requested = options.format ?? "auto";
-    let importer;
-    let sniff2 = null;
-    let source = input;
-    let peeked = null;
-    if (requested === "auto") {
-      peeked = await peekHead(input, SNIFF_HEAD_BYTES, options.signal ?? null);
-      source = peeked.input;
-      sniff2 = this.sniff({ filename: options.filename, mimeType: options.mimeType, head: peeked.head });
-      if (sniff2 === null) {
-        const report2 = new ImportReportBuilder("unknown", 0);
-        return report2.fail(
-          UNKNOWN_FORMAT_CODE,
-          `no registered importer recognises the input${describeHints(options)}; pass the format explicitly`,
-          void 0,
-          { formats: this.formats() }
-        );
-      }
-      importer = this.importer(sniff2.format);
-    } else {
-      importer = this.importer(requested);
-    }
-    const builder = new GraphBuilder({
-      weightDtype: options.weightDtype ?? "f64",
-      ...options.builder,
-      directed: true,
-      addMissingNodes: options.addMissingNodes ?? true,
-      duplicateEdges: options.duplicateEdges ?? "keep",
-      selfLoops: options.selfLoops ?? "keep"
-    });
+    const chosen = await this.choose(input, options);
+    const builder = seededBuilder(options);
     let report;
     try {
-      report = await importer.import(source, builder, importerOptions(options));
+      report = await chosen.importer.import(chosen.source, builder, importerOptions(options));
     } catch (err) {
-      await peeked?.close();
+      await chosen.peeked?.close();
       throw err;
     }
-    const frozen = builder.freezeWithReport(options.freeze);
-    return Object.freeze({
-      format: importer.format,
-      sniff: sniff2,
-      snapshot: frozen.snapshot,
-      report,
-      freeze: frozen.report
-    });
+    return result(chosen, builder, report, options);
+  }
+  /**
+   * Read every graph of an input (a DOT file with several graphs, a Pajek project with several
+   * networks, a JGF document with a `graphs` array), each into its own fresh builder, frozen.
+   * A format whose importer has no importAll() holds one graph per input, so the result has one
+   * entry. Options, sniffing and the builder seed are those of importGraph().
+   * @param input - the text, bytes, stream or chunks to read
+   * @param options - the format, hints, common and format-specific import options
+   * @returns one result per graph, in document order
+   */
+  async importAllGraphs(input, options = {}) {
+    const chosen = await this.choose(input, options);
+    const { importer } = chosen;
+    const builders = [];
+    let reports;
+    try {
+      if (importer.importAll === void 0) {
+        builders.push(seededBuilder(options));
+        reports = [await importer.import(chosen.source, builders[0], importerOptions(options))];
+      } else {
+        reports = await importer.importAll(
+          chosen.source,
+          () => {
+            const builder = seededBuilder(options);
+            builders.push(builder);
+            return builder;
+          },
+          importerOptions(options)
+        );
+      }
+    } catch (err) {
+      await chosen.peeked?.close();
+      throw err;
+    }
+    return reports.map((report, i3) => result(chosen, builders[i3], report, options));
+  }
+  /**
+   * The importer for an input: the named format, or the sniffed one.
+   * @param input - the input
+   * @param options - the importGraph options
+   * @returns the importer, the sniff, and the input to read (replayed for a stream)
+   */
+  async choose(input, options) {
+    const requested = options.format ?? "auto";
+    if (requested !== "auto") {
+      return { importer: this.importer(requested), sniff: null, source: input, peeked: null };
+    }
+    const peeked = await peekHead(input, SNIFF_HEAD_BYTES, options.signal ?? null);
+    const sniff2 = this.sniff({ filename: options.filename, mimeType: options.mimeType, head: peeked.head });
+    if (sniff2 === null) {
+      const report = new ImportReportBuilder("unknown", 0);
+      return report.fail(
+        UNKNOWN_FORMAT_CODE,
+        `no registered importer recognises the input${describeHints(options)}; pass the format explicitly`,
+        void 0,
+        { formats: this.formats() }
+      );
+    }
+    return { importer: this.importer(sniff2.format), sniff: sniff2, source: peeked.input, peeked };
   }
   /**
    * Write a snapshot in a format, as UTF-8 chunks (design section 8.5).
@@ -459,6 +489,9 @@ const registry = createRegistry();
 function importGraph(input, options) {
   return registry.importGraph(input, options);
 }
+function importAllGraphs(input, options) {
+  return registry.importAllGraphs(input, options);
+}
 function exportGraph(snapshot, format, options) {
   return registry.exportGraph(snapshot, format, options);
 }
@@ -480,6 +513,26 @@ function importerOptions(options) {
   }
   return out;
 }
+function seededBuilder(options) {
+  return new GraphBuilder({
+    weightDtype: options.weightDtype ?? "f64",
+    ...options.builder,
+    directed: true,
+    addMissingNodes: options.addMissingNodes ?? true,
+    duplicateEdges: options.duplicateEdges ?? "keep",
+    selfLoops: options.selfLoops ?? "keep"
+  });
+}
+function result(chosen, builder, report, options) {
+  const frozen = builder.freezeWithReport(options.freeze);
+  return Object.freeze({
+    format: chosen.importer.format,
+    sniff: chosen.sniff,
+    snapshot: frozen.snapshot,
+    report,
+    freeze: frozen.report
+  });
+}
 function unknownFormat(kind, format, known) {
   const supported = [...known];
   return new GraphFormatError(
@@ -601,13 +654,13 @@ function readerIterator(stream) {
       if (done) {
         return { done: true, value: void 0 };
       }
-      const result = await reader.read();
-      if (result.done) {
+      const result2 = await reader.read();
+      if (result2.done) {
         done = true;
         reader.releaseLock();
         return { done: true, value: void 0 };
       }
-      return { done: false, value: result.value };
+      return { done: false, value: result2.value };
     },
     async return() {
       if (!done) {
@@ -642,6 +695,7 @@ export {
   l as DirectionResolver,
   E as EMPTY_COLUMN_DROPPED_CODE,
   m as EMPTY_INPUT_CODE,
+  n as ENCODING_FALLBACK_CODE,
   FormatRegistry,
   GEXF_1_2_CAPABILITIES,
   GEXF_ISSUE,
@@ -652,94 +706,96 @@ export {
   a11 as GRAPHML_LOSS,
   GRAPH_FORMATS,
   H as HYPEREDGE_CODE,
-  n as ID_MERGED_CODE,
+  o as ID_MERGED_CODE,
   ID_SPACE_COLUMN,
-  o as ID_TEXT_COLLISION_CODE,
-  p as ID_TEXT_TYPE_CODE,
-  q as INTEGRAL_F64_CODE,
-  r as INVALID_UTF8_CODE,
-  s as IdCoercer,
-  u as ImportError,
+  p as ID_TEXT_COLLISION_CODE,
+  q as ID_TEXT_TYPE_CODE,
+  r as INTEGRAL_F64_CODE,
+  s as INVALID_ENCODING_CODE,
+  u as INVALID_UTF8_CODE,
+  v as IdCoercer,
+  w as ImportError,
   ImportReportBuilder,
   J2 as JSON_DIALECTS,
   a12 as JSON_ISSUE,
   b2 as JSON_LOSS,
   LABELS_COLUMN,
   L as LOSS,
-  v as LineReader,
+  x as LineReader,
   M as MISSING_ENDPOINT_CODE,
-  w as MISSING_ID_CODE,
-  x as MIXED_DIRECTION_CODE,
-  y as MULTIPLE_GRAPHS_CODE,
-  z as MUTUAL_AS_UNDIRECTED_CODE,
-  A as MUTUAL_COLUMN,
-  F as MUTUAL_EXPANDED_CODE,
+  y as MISSING_ID_CODE,
+  z as MIXED_DIRECTION_CODE,
+  A as MULTIPLE_GRAPHS_CODE,
+  F as MUTUAL_AS_UNDIRECTED_CODE,
+  G as MUTUAL_COLUMN,
+  J as MUTUAL_EXPANDED_CODE,
   NEO4J_CAPABILITIES,
   NEO4J_ISSUE,
   NEO4J_LOSS,
   N as NO_CAPABILITIES,
-  G as NO_GRAPH_CODE,
+  K as NO_GRAPH_CODE,
   O as OPTIONS_GAINED_CODE,
-  J as OPTION_IGNORED_CODE,
-  P as PAIR_COLUMN,
+  P as OPTION_IGNORED_CODE,
+  Q as PAIR_COLUMN,
   P2 as PAJEK_ISSUE,
   a13 as PAJEK_LOSS,
-  K as PARENTS_DROPPED_CODE,
-  Q as PARSE_ERROR_CODE,
-  R as PRECISION_CODE,
-  S as RENAMED_CODE,
-  T as ROLE_ASSUMED_CODE,
-  U as ROLE_DROPPED_CODE,
-  V as ROLE_TAKEN_CODE,
-  W as SINK_OPTION_CODE,
+  R as PARENTS_DROPPED_CODE,
+  S as PARSE_ERROR_CODE,
+  T as PRECISION_CODE,
+  U as RENAMED_CODE,
+  V as ROLE_ASSUMED_CODE,
+  W as ROLE_DROPPED_CODE,
+  X as ROLE_TAKEN_CODE,
+  Y as SINK_OPTION_CODE,
   SNIFF_HEAD_BYTES,
-  X as STORAGE_CLASS_CODE,
-  Y as STRAY_TEXT_CODE,
-  Z as SYNTAX_CODE,
-  _ as TEMPORAL_DROPPED_CODE,
-  $ as TEMPORAL_TEXT_DROPPED_CODE,
-  a0 as TEXT_INFERRED_CODE,
+  Z as STORAGE_CLASS_CODE,
+  _ as STRAY_TEXT_CODE,
+  $ as SYNTAX_CODE,
+  a0 as TEMPORAL_DROPPED_CODE,
+  a1 as TEMPORAL_TEXT_DROPPED_CODE,
+  a2 as TEXT_INFERRED_CODE,
   TYPE_COLUMN,
   T2 as TextCellWriter,
-  a1 as UNKNOWN_ATTR_TYPE_CODE,
-  a2 as UNKNOWN_ELEMENT_CODE,
+  a3 as UNKNOWN_ATTR_TYPE_CODE,
+  a4 as UNKNOWN_ELEMENT_CODE,
+  a5 as UNKNOWN_ENCODING_CODE,
   UNKNOWN_FORMAT_CODE,
-  a3 as UNKNOWN_PARENT_CODE,
-  a4 as UNKNOWN_TYPE_CODE,
-  a5 as WEIGHT_KEY_CLASH_CODE,
+  a6 as UNKNOWN_PARENT_CODE,
+  a7 as UNKNOWN_TYPE_CODE,
+  a8 as WEIGHT_KEY_CLASH_CODE,
   W2 as WIDENING_UNSUPPORTED_CODE,
-  a6 as XML_ILLEGAL_CHAR_CODE,
-  a7 as XML_SYNTAX_CODE,
+  a9 as XML_ILLEGAL_CHAR_CODE,
+  aa as XML_SYNTAX_CODE,
   X2 as XmlSyntaxError,
   a15 as XmlTokenizer,
-  a8 as canonicalId,
-  a9 as capabilities,
-  aa as checkCapabilities,
+  ab as canonicalId,
+  ac as capabilities,
+  ad as checkCapabilities,
   checkExport,
   c2 as childrenCsr,
   a as childrenFromColumn,
-  ab as coerceId,
-  ac as coerceIdText,
-  ad as collectBytes,
+  ae as coerceId,
+  af as coerceIdText,
+  ag as collectBytes,
   createRegistry,
   csvExporter,
   csvImporter,
-  ae as declareCompanion,
-  af as declareResolved,
-  ag as decodeChunks,
+  ah as declareCompanion,
+  ai as declareResolved,
+  aj as decodeChunks,
   d2 as dialectCapabilities,
   dotExporter,
   dotImporter,
-  ah as encodeChunks,
-  ai as explicitWeights,
+  ak as encodeChunks,
+  al as explicitWeights,
   exportGraph,
   exportGraphToString,
   extensionOf,
-  aj as formatDecimal,
-  ak as formatF32,
-  al as formatF64,
-  am as formatGmlReal,
-  an as formatInteger,
+  am as formatDecimal,
+  an as formatF32,
+  ao as formatF64,
+  ap as formatGmlReal,
+  aq as formatInteger,
   gexfExporter,
   gexfImporter,
   gmlExporter,
@@ -748,42 +804,43 @@ export {
   graphmlImporter,
   h2 as hasIllegalXmlChar,
   headBytes,
+  importAllGraphs,
   importGraph,
   i2 as inferTextDtype,
-  ao as inputLength,
-  ap as isAbortError,
-  aq as isCanonicalIntegerText,
-  ar as isImportInput,
-  as as isNmtoken,
+  ar as inputLength,
+  as as isAbortError,
+  at as isCanonicalIntegerText,
+  au as isImportInput,
+  av as isNmtoken,
   a14 as isNumericText,
-  at as isWeightField,
-  au as joinText,
+  aw as isWeightField,
+  ax as joinText,
   j2 as jsonCapabilities,
   jsonExporter,
   jsonImporter,
-  av as mangleNmtoken,
+  ay as mangleNmtoken,
   neo4jExporter,
   neo4jImporter,
   normalizeMimeType,
-  aw as pairFolding,
+  az as pairFolding,
   pajekExporter,
   pajekImporter,
   p2 as parseTextCell,
-  ax as parseWeightText,
+  aA as parseWeightText,
   rankFormats,
-  ay as readText,
+  aB as readText,
   registry,
-  az as reportSinkOptions,
-  aA as reportUnusedOptions,
-  aB as resolveExportOptions,
-  aC as resolveImportOptions,
-  aD as sanitizeIds,
+  aC as reportSinkOptions,
+  aD as reportUnusedOptions,
+  aE as resolveExportOptions,
+  aF as resolveImportOptions,
+  aG as sanitizeIds,
   sniff,
   sniffFormat,
   sniffJsonDialectHead,
   t as textChunks,
   throwIfAborted,
-  aE as toReadableStream,
+  aH as toReadableStream,
   t2 as tokenizeXml,
   x2 as xmlIllegalTextNotes
 };