feat(asyncDropWhileOnce): add asyncDropWhileOnce function

Author: djcsdy

index.test.ts

@@ -2,6 +2,7 @@ import type {ExecutionContext} from "ava";
 import test from "ava";
 import {
     asyncDropOnce,
+    asyncDropWhileOnce,
     asyncEmptyOnce,
     asyncInitialOnce,
     asyncIterator,
@@ -233,3 +234,25 @@ test("asyncTakeUntilOnce", async t => {
         [1, 2, 3]
     );
 });
+
+test("asyncDropWhileOnce", async t => {
+    t.deepEqual(await asyncToArrayOnce(asyncDropWhileOnce(asyncIterator([]), (_, i) => i < 3)), []);
+    t.deepEqual(
+        await asyncToArrayOnce(asyncDropWhileOnce(asyncIterator([1, 2]), (_, i) => i < 3)),
+        []
+    );
+    t.deepEqual(
+        await asyncToArrayOnce(asyncDropWhileOnce(asyncIterator([1, 2, 3, 4, 5]), (_, i) => i < 3)),
+        [4, 5]
+    );
+    t.deepEqual(
+        await asyncToArrayOnce(asyncDropWhileOnce(asyncIterator([1, 2, 3, 4, 5]), () => false)),
+        [1, 2, 3, 4, 5]
+    );
+    t.deepEqual(
+        await asyncToArrayOnce(
+            asyncDropWhileOnce(asyncIterator([1, 2, 3, 4, 3, 2, 1]), e => e < 4)
+        ),
+        [4, 3, 2, 1]
+    );
+});

index.ts

@@ -370,3 +370,28 @@ export function asyncTakeUntilOnceFn<T>(
 ): (iterator: AsyncIteratorLike<T>) => AsyncIterator<T> {
     return iterator => asyncTakeUntilOnce(iterator, predicate);
 }
+
+export function asyncDropWhileOnce<T>(
+    iterator: AsyncIteratorLike<T>,
+    predicate: (element: T, index: number) => boolean | Promise<boolean>
+): AsyncIterator<T> {
+    const it = asyncIterator(iterator);
+    let i = 0;
+    const before = async (): Promise<IteratorResult<T>> => {
+        let element = await it.next();
+        while (element.done !== true && (await predicate(element.value, i++))) {
+            element = await it.next();
+        }
+        next = during;
+        return element;
+    };
+    const during = async (): Promise<IteratorResult<T>> => it.next();
+    let next = before;
+    return {next: async () => next()};
+}
+
+export function asyncDropWhileOnceFn<T>(
+    predicate: (element: T, index: number) => boolean | Promise<boolean>
+): (iterator: AsyncIteratorLike<T>) => AsyncIterator<T> {
+    return iterator => asyncDropWhileOnce(iterator, predicate);
+}