feat(asyncConcatOnce): add asyncConcatOnce function

Author: djcsdy

index.test.ts

@@ -5,6 +5,7 @@ import {
     asyncAndOnce,
     asyncAnyOnce,
     asyncAverageOnce,
+    asyncConcatOnce,
     asyncContainsOnce,
     asyncDropOnce,
     asyncDropUntilOnce,
@@ -510,3 +511,25 @@ test("asyncAllOnce", async t => {
     t.true(await asyncAllOnce(asyncIterator([1, 2, 3]), e => e < 4));
     t.false(await asyncAllOnce(asyncIterator([1, 2, 3]), e => e > 2));
 });
+
+test("asyncConcatOnce", async t => {
+    t.deepEqual(
+        await asyncToArrayOnce(
+            asyncConcatOnce(
+                asyncIterator([
+                    asyncIterator([1, 2]),
+                    asyncIterator([]),
+                    asyncIterator([3]),
+                    asyncIterator([4, 5])
+                ])
+            )
+        ),
+        [1, 2, 3, 4, 5]
+    );
+    t.deepEqual(
+        await asyncToArrayOnce(
+            asyncConcatOnce(asyncIterator([asyncIterator([]), asyncIterator([])]))
+        ),
+        []
+    );
+});

index.ts

@@ -993,3 +993,39 @@ export function asyncAllOnceFn<T>(
 ): (iterator: AsyncIteratorLike<T>) => Promise<boolean> {
     return async iterator => asyncAllOnce(iterator, predicate);
 }
+
+export function asyncConcatOnce<T>(
+    iterators: AsyncIteratorLike<AsyncIteratorLike<T>>
+): AsyncIterator<T> {
+    const its = asyncIterator(iterators);
+    const done: IteratorResult<T> = {done: true, value: undefined};
+    const first = async (): Promise<IteratorResult<T>> => {
+        const itElement = await its.next();
+        if (itElement.done === true) {
+            next = after;
+            return done;
+        } else {
+            next = during(asyncIterator(itElement.value));
+            return next();
+        }
+    };
+    const during = (iterator: AsyncIterator<T>) => async (): Promise<IteratorResult<T>> => {
+        let element = await iterator.next();
+        while (element.done === true) {
+            const itElement = await its.next();
+            if (itElement.done === true) {
+                next = after;
+                return done;
+            } else {
+                const iterator = asyncIterator(itElement.value);
+                next = during(iterator);
+                element = await iterator.next();
+            }
+        }
+
+        return element;
+    };
+    const after = async (): Promise<IteratorResult<T>> => done;
+    let next = first;
+    return {next: async () => next()};
+}