Function normalizeAsyncValue

lib/internal/streams/iter/from.js:266–330

* Normalize an async streamable yield value to Uint8Array chunks. * Recursively flattens arrays, iterables, async iterables, promises, * and protocol conversions. * @yields {Uint8Array}

(value)

 * @yields {Uint8Array}
 */
async function* normalizeAsyncValue(value) {
  // Handle promises first
  if (isPromise(value)) {
    const resolved = await value;
    yield* normalizeAsyncValue(resolved);
    return;
  }

  // Handle primitives
  if (isPrimitiveChunk(value)) {
    yield primitiveToUint8Array(value);
    return;
  }

  // Handle ToAsyncStreamable protocol (check before ToStreamable)
  if (hasProtocol(value, toAsyncStreamable)) {
    const result = FunctionPrototypeCall(value[toAsyncStreamable], value);
    if (isPromise(result)) {
      yield* normalizeAsyncValue(await result);
    } else {
      yield* normalizeAsyncValue(result);
    }
    return;
  }

  // Handle ToStreamable protocol
  if (hasProtocol(value, toStreamable)) {
    const result = FunctionPrototypeCall(value[toStreamable], value);
    yield* normalizeAsyncValue(result);
    return;
  }

  // Handle arrays (which are also iterable, but check first for efficiency)
  if (ArrayIsArray(value)) {
    for (let i = 0; i < value.length; i++) {
      yield* normalizeAsyncValue(value[i]);
    }
    return;
  }

  // Handle async iterables (check before sync iterables since some objects
  // have both)
  if (isAsyncIterable(value)) {
    for await (const item of value) {
      yield* normalizeAsyncValue(item);
    }
    return;
  }

  // Handle sync iterables
  if (isSyncIterable(value)) {
    for (const item of value) {
      yield* normalizeAsyncValue(item);
    }
    return;
  }

  // Reject: no valid conversion