feat(asyncSliceOnce): add asyncSliceOnce function

Author: djcsdy

index.test.ts

@@ -8,6 +8,7 @@ import {
     asyncNotEmptyOnce,
     asyncOnlyOnce,
     asyncPushOnce,
+    asyncSliceOnce,
     asyncTailOnce,
     asyncToArrayOnce,
     asyncUnshiftOnce
@@ -146,3 +147,16 @@ test("asyncNotEmptyOnce", async t => {
     t.is(await asyncNotEmptyOnce(asyncIterator([1])), true);
     t.is(await asyncNotEmptyOnce(asyncIterator([1, 2, 3])), true);
 });
+
+test("asyncSliceOnce", async t => {
+    t.deepEqual(await asyncToArrayOnce(asyncSliceOnce(asyncIterator([1, 2, 3, 4]), 1)), [2, 3, 4]);
+    t.deepEqual(
+        await asyncToArrayOnce(asyncSliceOnce(asyncIterator([1, 2, 3, 4, 5]), 1, 4)),
+        [2, 3, 4]
+    );
+    t.deepEqual(await asyncToArrayOnce(asyncSliceOnce(asyncIterator([1, 2, 3]), 2)), [3]);
+    t.deepEqual(await asyncToArrayOnce(asyncSliceOnce(asyncIterator([1, 2, 3]), 0, 2)), [1, 2]);
+    t.deepEqual(await asyncToArrayOnce(asyncSliceOnce(asyncIterator([]), 3, 5)), []);
+    t.deepEqual(await asyncToArrayOnce(asyncSliceOnce(asyncIterator([1, 2, 3]), 2, 0)), []);
+    t.deepEqual(await asyncToArrayOnce(asyncSliceOnce(asyncIterator([1, 2, 3]), 1, 1)), []);
+});

index.ts

@@ -194,3 +194,56 @@ export async function asyncEmptyOnce<T>(iterator: AsyncIteratorLike<T>): Promise
 export async function asyncNotEmptyOnce<T>(iterator: AsyncIteratorLike<T>): Promise<boolean> {
     return (await asyncIterator(iterator).next()).done !== true;
 }
+
+export function asyncSliceOnce<T>(
+    iterator: AsyncIteratorLike<T>,
+    start: number | Promise<number> = 0,
+    end: number | Promise<number> = Infinity
+): AsyncIterator<T> {
+    const it = asyncIterator(iterator);
+    let i = 0;
+    const done: IteratorResult<T> = {done: true, value: undefined};
+    const first = async (): Promise<IteratorResult<T>> => {
+        if ((await end) <= (await start)) {
+            next = after;
+            return done;
+        } else {
+            next = before;
+            return before();
+        }
+    };
+    const before = async (): Promise<IteratorResult<T>> => {
+        let element = await it.next();
+        const s = await start;
+        while (i++ < s && element.done !== true) {
+            element = await it.next();
+        }
+
+        if (element.done === true) {
+            next = after;
+            return done;
+        } else {
+            next = during;
+            return element;
+        }
+    };
+    const during = async (): Promise<IteratorResult<T>> => {
+        const element = await it.next();
+        if (i++ < (await end) && element.done !== true) {
+            return element;
+        } else {
+            next = after;
+            return done;
+        }
+    };
+    const after = async (): Promise<IteratorResult<T>> => done;
+    let next = first;
+    return {next: async () => next()};
+}
+
+export function asyncSliceOnceFn<T>(
+    start: number | Promise<number>,
+    end: number | Promise<number> = Infinity
+): (iterator: AsyncIteratorLike<T>) => AsyncIterator<T> {
+    return iterator => asyncSliceOnce(iterator, start, end);
+}