feat(asyncExcludeFirstOnce): add asyncExcludeFirstOnce function

Author: djcsdy

index.test.ts

@@ -6,6 +6,7 @@ import {
     asyncDropWhileOnce,
     asyncEmptyOnce,
     asyncEqualOnce,
+    asyncExcludeFirstOnce,
     asyncExcludeNullOnce,
     asyncExcludeOnce,
     asyncFilterOnce,
@@ -379,3 +380,12 @@ test("asyncExcludeNullOnce", async t => {
         "b"
     ]);
 });
+
+test("asyncExcludeFirstOnce", async t => {
+    t.deepEqual(
+        await asyncToArrayOnce(
+            asyncExcludeFirstOnce(asyncIterator([1, 2, 3, 4, 3, 2, 1]), n => n > 2)
+        ),
+        [1, 2, 4, 3, 2, 1]
+    );
+});

index.ts

@@ -573,3 +573,28 @@ export function asyncExcludeNullOnce<T>(
 ): AsyncIterator<T> {
     return asyncFilterOnce(iterator, isNotNull);
 }
+
+export function asyncExcludeFirstOnce<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>> => {
+        const element = await it.next();
+        if (element.done !== true && !(await predicate(element.value, i++))) {
+            return element;
+        }
+        next = after;
+        return it.next();
+    };
+    const after = async (): Promise<IteratorResult<T>> => it.next();
+    let next = before;
+    return {next: async () => next()};
+}
+
+export function asyncExcludeFirstOnceFn<T>(
+    predicate: (element: T, index: number) => boolean | Promise<boolean>
+): (iterator: AsyncIteratorLike<T>) => AsyncIterator<T> {
+    return iterator => asyncExcludeFirstOnce(iterator, predicate);
+}