fix: don't use yield* at all

Author: jeengbe

spec/asynciterable-operators/finalize-spec.ts

@@ -1,6 +1,6 @@
 import { hasNext, hasErr, noNext } from '../asynciterablehelpers.js';
 import { range, throwError } from 'ix/asynciterable/index.js';
-import { finalize, tap, concatMap } from 'ix/asynciterable/operators/index.js';
+import { finalize, tap, flatMap } from 'ix/asynciterable/operators/index.js';
 
 test('AsyncIterable#finalize defers behavior', async () => {
   let done = false;
@@ -79,7 +79,7 @@ test('AsyncIterable#finalize calls with downstream error from flattening', async
     finalize(async () => {
       done = true;
     }),
-    concatMap(async (x) => {
+    flatMap(async (x) => {
       // srcValues.push(x);
       if (x === 1) {
         return throwError(err);

spec/asynciterable-operators/mergeall-spec.ts

@@ -4,5 +4,5 @@ import { mergeAll } from 'ix/asynciterable/operators/index.js';
 
 test('AsyncIterable#merge mergeAll behavior', async () => {
   const res = of(of(1, 2, 3), of(4, 5)).pipe(mergeAll());
-  expect(await toArray(res)).toEqual([1, 2, 4, 3, 5]);
+  expect(await toArray(res)).toEqual([1, 4, 2, 5, 3]);
 });

spec/asynciterable/concat-spec.ts

@@ -1,7 +1,25 @@
+import { take } from 'ix/asynciterable/operators.js';
 import '../asynciterablehelpers.js';
-import { concat, of, sequenceEqual } from 'ix/asynciterable/index.js';
+import { concat, of, sequenceEqual, toArray } from 'ix/asynciterable/index.js';
 
 test('AsyncIterable#concat behavior', async () => {
   const res = concat(of(1, 2, 3), of(4, 5));
   expect(await sequenceEqual(res, of(1, 2, 3, 4, 5))).toBeTruthy();
 });
+
+test("AsyncIterable#concat doesn't execute more than necessary", async () => {
+  let i = 0;
+
+  async function* asyncGenerator() {
+    i++;
+    yield 1;
+  }
+
+  const res = concat(asyncGenerator(), asyncGenerator()).pipe(take(1));
+  const items = await toArray(res);
+
+  expect(items).toEqual([1]);
+  // This second generator should not be started at all since the first one
+  // provides enough values
+  expect(i).toBe(1);
+});

src/asynciterable/catcherror.ts

@@ -22,7 +22,9 @@ export class CatchAllAsyncIterable<TSource> extends AsyncIterableX<TSource> {
       hasError = false;
 
       try {
-        yield* wrapWithAbort(source, signal);
+        for await (const item of wrapWithAbort(source, signal)) {
+          yield item;
+        }
       } catch (e) {
         error = e;
         hasError = true;

src/asynciterable/concat.ts

@@ -15,7 +15,9 @@ export class ConcatAsyncIterable<TSource> extends AsyncIterableX<TSource> {
     throwIfAborted(signal);
 
     for (const outer of this._source) {
-      yield* wrapWithAbort(outer, signal);
+      for await (const inner of wrapWithAbort(outer, signal)) {
+        yield inner;
+      }
     }
   }
 }

src/asynciterable/create.ts

@@ -14,9 +14,11 @@ class AnonymousAsyncIterable<T> extends AsyncIterableX<T> {
 
     const it = await this._fn(signal);
 
-    yield* {
+    for await (const item of {
       [Symbol.asyncIterator]: () => it,
-    };
+    }) {
+      yield item;
+    }
   }
 }
 

src/asynciterable/defer.ts

@@ -15,7 +15,9 @@ class DeferAsyncIterable<TSource> extends AsyncIterableX<TSource> {
   async *[Symbol.asyncIterator](signal?: AbortSignal) {
     throwIfAborted(signal);
 
-    yield* wrapWithAbort(await this._fn(signal), signal);
+    for await (const item of wrapWithAbort(await this._fn(signal), signal)) {
+      yield item;
+    }
   }
 }
 

src/asynciterable/fromdomstream.ts

@@ -41,7 +41,9 @@ async function* _consumeReader<T>(
 ): AsyncIterator<T, any, undefined> {
   let threw = false;
   try {
-    yield* iterator;
+    for await (const item of iterator) {
+      yield item;
+    }
   } catch (e) {
     if ((threw = true) && reader) {
       await reader['cancel'](e);

src/asynciterable/of.ts

@@ -13,7 +13,9 @@ export class OfAsyncIterable<TSource> extends AsyncIterableX<TSource> {
   async *[Symbol.asyncIterator](signal?: AbortSignal) {
     throwIfAborted(signal);
 
-    yield* this._args;
+    for await (const item of this._args) {
+      yield item;
+    }
   }
 }
 

src/asynciterable/onerrorresumenext.ts

@@ -14,9 +14,11 @@ export class OnErrorResumeNextAsyncIterable<TSource> extends AsyncIterableX<TSou
   async *[Symbol.asyncIterator](signal?: AbortSignal) {
     throwIfAborted(signal);
 
-    for (const item of this._source) {
+    for (const outer of this._source) {
       try {
-        yield* wrapWithAbort(item, signal);
+        for await (const inner of wrapWithAbort(outer, signal)) {
+          yield inner;
+        }
       } catch {
         // ignore
       }