Function applyStatelessAsyncTransform

src/pull.ts:365–420

* Apply a single stateless async transform to a source.

(
  source: AsyncIterable<Uint8Array[] | null>,
  transform: TransformFn,
  options: TransformCallbackOptions
)

/**
 * Apply a single stateless async transform to a source.
 */
async function* applyStatelessAsyncTransform(
  source: AsyncIterable<Uint8Array[] | null>,
  transform: TransformFn,
  options: TransformCallbackOptions
): AsyncGenerator<Uint8Array[]> {
  for await (const chunks of source) {
    const result = transform(chunks, options);
    // Fast path: result is already Uint8Array[] (common case)
    if (result === null) continue;
    if (isUint8ArrayBatch(result)) {
      if (result.length > 0) {
        yield result;
      }
      continue;
    }
    // Handle Promise of Uint8Array[]
    if (result instanceof Promise) {
      const resolved = await result;
      if (resolved === null) continue;
      if (isUint8ArrayBatch(resolved)) {
        if (resolved.length > 0) {
          yield resolved;
        }
        continue;
      }
      // Fall through to slow path
      yield* processTransformResultAsync(resolved);
      continue;
    }
    // Fast path: sync generator/iterable - collect all yielded items into batches
    // This avoids the overhead of processTransformResultAsync for simple generators
    if (isSyncIterable(result) && !isAsyncIterable(result)) {
      const batch: Uint8Array[] = [];
      for (const item of result as Iterable<unknown>) {
        // Fast path: item is Uint8Array[] batch (common for generators that yield batches)
        if (isUint8ArrayBatch(item)) {
          batch.push(...(item as Uint8Array[]));
        } else if (item instanceof Uint8Array) {
          // Single Uint8Array
          batch.push(item);
        } else if (item !== null && item !== undefined) {
          // Other item types - flatten and add to batch
          for await (const chunk of flattenTransformYieldAsync(item as TransformYield)) {
            batch.push(chunk);
          }
        }
      }
      if (batch.length > 0) {
        yield batch;
      }
      continue;
    }
    // Slow path for other types (async iterables, complex nested structures)
    yield* processTransformResultAsync(result);
  }
}