@graphty/graph-io 0.3.40 → 0.3.41

package/dist/chunks/{export-B-aVCwyG.js → export-DD3Lvw-F.js}

@@ -804,29 +804,12 @@ function declareResolved(sink, domain, decl, report, where) {
         throw err;
       }
       if (err.code === "E_COLUMN_EXISTS" && !renamed) {
-        const taken = takenIn(sink, domain);
-        const id = current.origin?.id ?? null;
-        const name = uniqueColumnName(current.name, id, taken);
-        report.warning(
-          "coercion",
-          COLUMN_RENAMED_CODE,
-          `${domain} column "${current.name}" renamed to "${name}": the sink already holds that name with another shape`,
-          { ...where, element: where?.element ?? current.name }
-        );
-        current = { ...current, name };
+        current = renameColumn(sink, domain, current, report, where);
         renamed = true;
         continue;
       }
       if (err.code === "E_DUPLICATE_ROLE" && current.role !== void 0 && !roleDropped) {
-        const holder = typeof err.details.holder === "string" ? err.details.holder : "another column";
-        report.warning(
-          "coercion",
-          ROLE_TAKEN_CODE,
-          `${domain} column "${current.name}" loses the ${current.role} role: "${holder}" already holds it`,
-          { ...where, element: where?.element ?? current.name }
-        );
-        const { role: _role, ...withoutRole } = current;
-        current = withoutRole;
+        current = dropRole(err, domain, current, current.role, report, where);
         roleDropped = true;
         continue;
       }
@@ -834,6 +817,29 @@ function declareResolved(sink, domain, decl, report, where) {
     }
   }
 }
+function renameColumn(sink, domain, decl, report, where) {
+  const taken = takenIn(sink, domain);
+  const id = decl.origin?.id ?? null;
+  const name = uniqueColumnName(decl.name, id, taken);
+  report.warning(
+    "coercion",
+    COLUMN_RENAMED_CODE,
+    `${domain} column "${decl.name}" renamed to "${name}": the sink already holds that name with another shape`,
+    { ...where, element: where?.element ?? decl.name }
+  );
+  return { ...decl, name };
+}
+function dropRole(err, domain, decl, role, report, where) {
+  const holder = typeof err.details.holder === "string" ? err.details.holder : "another column";
+  report.warning(
+    "coercion",
+    ROLE_TAKEN_CODE,
+    `${domain} column "${decl.name}" loses the ${role} role: "${holder}" already holds it`,
+    { ...where, element: where?.element ?? decl.name }
+  );
+  const { role: _role, ...withoutRole } = decl;
+  return withoutRole;
+}
 function declareCompanion(sink, domain, companion, report) {
   try {
     return declareOn(sink, domain, companion);
@@ -2300,124 +2306,175 @@ function reportTextEncoding(report, encoding) {
 async function* textChunks(rawInput, report, options = {}) {
   const input = normalizeInput(rawInput);
   const signal = options.signal ?? null;
-  const onProgress = options.onProgress ?? null;
   const filter = new TextFilter(report, options);
   throwIfAborted(signal);
   if (typeof input === "string") {
     reportTextEncoding(report, options.encoding);
-    const total = onProgress === null ? 0 : utf8Length(input);
-    let done2 = 0;
-    let start = 0;
-    while (start < input.length) {
-      throwIfAborted(signal);
-      let end = Math.min(start + DECODE_SLICE, input.length);
-      const highSurrogate = (input.charCodeAt(end - 1) & 64512) === 55296;
-      if (end < input.length && highSurrogate) {
-        end++;
-      }
-      const piece = start === 0 && end === input.length ? input : input.slice(start, end);
-      start = end;
-      const text = filter.push(piece);
-      if (text.length > 0) {
-        yield text;
-      }
-      if (onProgress !== null) {
-        done2 += utf8Length(piece);
-        onProgress(done2, total);
-      }
-    }
-    if (input.length === 0) {
-      onProgress?.(0, 0);
-    }
-    filter.end();
+    yield* stringTextChunks(input, filter, options);
     return;
   }
   const decoder = new ByteDecoder(report, options);
-  const headBytes = Math.max(options.declarationBytes ?? HEAD_BYTES, BOM_BYTES);
   if (input instanceof Uint8Array) {
-    const length = input.byteLength;
-    decoder.start(input.subarray(0, headBytes));
-    for (let offset = 0; offset < length; offset += DECODE_SLICE) {
-      throwIfAborted(signal);
-      if (input.byteLength !== length) {
-        throw new GraphFormatError(
-          "E_UNSUPPORTED",
-          "the input's buffer was detached (transferred) or resized during the import",
-          { reason: "detached" }
-        );
-      }
-      const slice = input.subarray(offset, Math.min(offset + DECODE_SLICE, length));
-      const text = filter.push(decoder.decode(slice, offset + DECODE_SLICE < length));
-      if (text.length > 0) {
-        yield text;
-      }
-      onProgress?.(Math.min(offset + DECODE_SLICE, length), length);
-    }
-    if (length === 0) {
-      onProgress?.(0, 0);
-    }
-    filter.end();
+    yield* byteTextChunks(input, filter, decoder, options);
     return;
   }
-  const needed = options.declaredEncoding === void 0 ? BOM_BYTES : headBytes;
+  const stream = new StreamText(filter, decoder, options);
+  for await (const chunk of isReadableStream(input) ? streamChunks(input, signal) : input) {
+    throwIfAborted(signal);
+    const text = stream.push(chunk);
+    if (text.length > 0) {
+      yield text;
+    }
+    options.onProgress?.(stream.done);
+  }
+  const tail = stream.end();
+  if (tail.length > 0) {
+    yield tail;
+  }
+  filter.end();
+  options.onProgress?.(stream.done, stream.done);
+}
+function stringSliceEnd(input, start) {
+  const end = Math.min(start + DECODE_SLICE, input.length);
+  const highSurrogate = (input.charCodeAt(end - 1) & 64512) === 55296;
+  return end < input.length && highSurrogate ? end + 1 : end;
+}
+function* stringTextChunks(input, filter, options) {
+  const signal = options.signal ?? null;
+  const onProgress = options.onProgress ?? null;
+  const total = onProgress === null ? 0 : utf8Length(input);
   let done = 0;
-  let head = [];
-  let headLength = 0;
-  const flushHead = (stream) => {
-    const bytes = concatBytes(head);
-    head = [];
-    headLength = 0;
-    decoder.start(bytes.subarray(0, headBytes));
-    return decoder.decode(bytes, stream);
-  };
-  const chunks = isReadableStream(input) ? streamChunks(input, signal) : input;
-  for await (const chunk of chunks) {
+  let start = 0;
+  while (start < input.length) {
+    throwIfAborted(signal);
+    const end = stringSliceEnd(input, start);
+    const piece = start === 0 && end === input.length ? input : input.slice(start, end);
+    start = end;
+    const text = filter.push(piece);
+    if (text.length > 0) {
+      yield text;
+    }
+    if (onProgress !== null) {
+      done += utf8Length(piece);
+      onProgress(done, total);
+    }
+  }
+  if (input.length === 0) {
+    onProgress?.(0, 0);
+  }
+  filter.end();
+}
+function* byteTextChunks(input, filter, decoder, options) {
+  const signal = options.signal ?? null;
+  const length = input.byteLength;
+  decoder.start(input.subarray(0, headByteCount(options)));
+  for (let offset = 0; offset < length; offset += DECODE_SLICE) {
     throwIfAborted(signal);
-    let text;
-    const bytes = typeof chunk === "string" ? null : asBytes(chunk);
+    if (input.byteLength !== length) {
+      throw new GraphFormatError(
+        "E_UNSUPPORTED",
+        "the input's buffer was detached (transferred) or resized during the import",
+        { reason: "detached" }
+      );
+    }
+    const slice = input.subarray(offset, Math.min(offset + DECODE_SLICE, length));
+    const text = filter.push(decoder.decode(slice, offset + DECODE_SLICE < length));
+    if (text.length > 0) {
+      yield text;
+    }
+    options.onProgress?.(Math.min(offset + DECODE_SLICE, length), length);
+  }
+  if (length === 0) {
+    options.onProgress?.(0, 0);
+  }
+  filter.end();
+}
+function headByteCount(options) {
+  return Math.max(options.declarationBytes ?? HEAD_BYTES, BOM_BYTES);
+}
+class StreamText {
+  /**
+   * Create the reader of one stream input.
+   * @param filter - the text checks
+   * @param decoder - the byte decoder
+   * @param options - progress, the declaration reader and its size
+   */
+  constructor(filter, decoder, options) {
+    this.filter = filter;
+    this.decoder = decoder;
+    this.done = 0;
+    this.head = [];
+    this.headLength = 0;
+    this.headBytes = headByteCount(options);
+    this.needed = options.declaredEncoding === void 0 ? BOM_BYTES : this.headBytes;
+    this.counting = (options.onProgress ?? null) !== null;
+  }
+  /**
+   * Read the next chunk.
+   * @param chunk - a string or a Uint8Array (anything else is E_UNSUPPORTED)
+   * @returns its filtered text; empty while bytes are held back
+   */
+  push(chunk) {
     if (typeof chunk === "string") {
-      let pending = "";
-      if (headLength > 0) {
-        pending = decoder.flushBeforeText(() => flushHead(false));
-      } else if (decoder.started) {
-        pending = decoder.flushBeforeText(() => decoder.decode(new Uint8Array(0), false));
-      } else {
-        decoder.start(new Uint8Array(0));
-      }
-      text = filter.push(pending + chunk);
-      done += onProgress === null ? 0 : utf8Length(chunk);
-    } else if (bytes !== null) {
-      done += bytes.byteLength;
-      if (decoder.started) {
-        text = filter.push(decoder.decode(bytes, true));
-      } else {
-        head.push(bytes);
-        headLength += bytes.byteLength;
-        text = headLength >= needed ? filter.push(flushHead(true)) : "";
-      }
-    } else {
+      this.done += this.counting ? utf8Length(chunk) : 0;
+      return this.filter.push(this.beforeText() + chunk);
+    }
+    const bytes = asBytes(chunk);
+    if (bytes === null) {
       throw new GraphFormatError("E_UNSUPPORTED", "an input chunk must be a string or a Uint8Array", {
         reason: "chunk type",
         found: typeof chunk
       });
     }
-    if (text.length > 0) {
-      yield text;
+    this.done += bytes.byteLength;
+    if (this.decoder.started) {
+      return this.filter.push(this.decoder.decode(bytes, true));
+    }
+    this.head.push(bytes);
+    this.headLength += bytes.byteLength;
+    return this.headLength >= this.needed ? this.filter.push(this.flushHead(true)) : "";
+  }
+  /**
+   * The input ended: the filtered text of whatever is still held or pending.
+   * @returns the text
+   */
+  end() {
+    let tail = "";
+    if (this.headLength > 0) {
+      tail = this.flushHead(false);
+    } else if (this.decoder.started) {
+      tail = this.decoder.decode(new Uint8Array(0), false);
     }
-    onProgress?.(done);
+    return this.filter.push(tail);
   }
-  let tail = "";
-  if (headLength > 0) {
-    tail = flushHead(false);
-  } else if (decoder.started) {
-    tail = decoder.decode(new Uint8Array(0), false);
+  /**
+   * Start the decoder on the held bytes and decode them.
+   * @param stream - whether more bytes follow
+   * @returns their text
+   */
+  flushHead(stream) {
+    const bytes = concatBytes(this.head);
+    this.head = [];
+    this.headLength = 0;
+    this.decoder.start(bytes.subarray(0, this.headBytes));
+    return this.decoder.decode(bytes, stream);
   }
-  tail = filter.push(tail);
-  if (tail.length > 0) {
-    yield tail;
+  /**
+   * A text chunk follows: finish any byte sequence still pending in the decoder before switching
+   * to text. The BOM and declaration checks apply to the start of the input only, so bytes after
+   * text are never taken for a BOM.
+   * @returns the text of the pending bytes
+   */
+  beforeText() {
+    if (this.headLength > 0) {
+      return this.decoder.flushBeforeText(() => this.flushHead(false));
+    }
+    if (this.decoder.started) {
+      return this.decoder.flushBeforeText(() => this.decoder.decode(new Uint8Array(0), false));
+    }
+    this.decoder.start(new Uint8Array(0));
+    return "";
   }
-  filter.end();
-  onProgress?.(done, done);
 }
 function isReadableStream(input) {
   return typeof input.getReader === "function";
@@ -4368,4 +4425,4 @@ export {
   INVALID_ENCODING_CODE as y,
   INVALID_UTF8_CODE as z
 };
-//# sourceMappingURL=export-B-aVCwyG.js.map
+//# sourceMappingURL=export-DD3Lvw-F.js.map