@daiso-tech/core 0.3.0 → 0.5.0

package/dist/esm/collection/async-iterable-collection/async-iterable-collection.js

@@ -1,6 +1,8 @@
-import { CollectionError, ItemNotFoundCollectionError, MultipleItemsFoundCollectionError, UnexpectedCollectionError, TypeCollectionError, EmptyCollectionError, } from "../../contracts/collection/_module";
-import { AsyncCrossJoinIterable, AsyncSlidingIteralbe, AsyncShuffleIterable, AsyncEntriesIterable, AsyncFilterIterable, AsyncChunkIterable, AsyncChunkWhileIterable, AsyncCollapseIterable, AsyncCountByIterable, AsyncFlatMapIterable, AsyncGroupByIterable, AsyncInsertAfterIterable, AsyncInsertBeforeIterable, AsyncMapIterable, AsyncMergeIterable, AsyncPadEndIterable, AsyncPadStartIterable, AsyncPartionIterable, AsyncSkipIterable, AsyncSkipUntilIterable, AsyncSortIterable, AsyncSplitIterable, AsyncTakeIterable, AsyncTakeUntilIterable, AsyncTapIterable, AsyncUniqueIterable, AsyncUpdateIterable, AsyncWhenIterable, AsyncZipIterable, AsyncReverseIterable, AsyncSliceIterable, AsyncRepeatIterable, AsyncAbortIterable, AsyncDelayIterable, AsyncTimeoutIterable, } from "../../collection/async-iterable-collection/_shared/_module";
+import { ItemNotFoundCollectionError, MultipleItemsFoundCollectionError, UnexpectedCollectionError, TypeCollectionError, EmptyCollectionError, } from "../../contracts/collection/_module";
+import { AsyncErrorHandlerIterable, AsyncCrossJoinIterable, AsyncSlidingIteralbe, AsyncShuffleIterable, AsyncEntriesIterable, AsyncFilterIterable, AsyncChunkIterable, AsyncChunkWhileIterable, AsyncCollapseIterable, AsyncCountByIterable, AsyncFlatMapIterable, AsyncGroupByIterable, AsyncInsertAfterIterable, AsyncInsertBeforeIterable, AsyncMapIterable, AsyncMergeIterable, AsyncPadEndIterable, AsyncPadStartIterable, AsyncPartionIterable, AsyncSkipIterable, AsyncSkipUntilIterable, AsyncSortIterable, AsyncSplitIterable, AsyncTakeIterable, AsyncTakeUntilIterable, AsyncTapIterable, AsyncUniqueIterable, AsyncUpdateIterable, AsyncWhenIterable, AsyncZipIterable, AsyncReverseIterable, AsyncSliceIterable, AsyncRepeatIterable, } from "../../collection/async-iterable-collection/_shared/_module";
 import { simplifyAsyncLazyable } from "../../_shared/utilities";
+import { abortableIterable, delayIterable, LazyPromise } from "../../_module";
+import { AbortAsyncError, TimeoutAsyncError, timeoutIterable, } from "../../async/_module";
 export class AsyncIterableCollection {
     iterable;
     static DEFAULT_CHUNK_SIZE = 1024;
@@ -34,41 +36,45 @@ export class AsyncIterableCollection {
     map(mapFn) {
         return new AsyncIterableCollection(new AsyncMapIterable(this, mapFn));
     }
-    async reduce(reduceFn, initialValue) {
-        if (initialValue === undefined && (await this.isEmpty())) {
-            throw new TypeCollectionError("Reduce of empty array must be inputed a initial value");
-        }
-        if (initialValue !== undefined) {
-            let output = initialValue;
-            for await (const [index, item] of this.entries()) {
-                output = await reduceFn(output, item, index, this);
-            }
-            return output;
-        }
-        let output = (await this.firstOrFail()), index = 0, isFirstIteration = true;
-        for await (const item of this) {
-            if (!isFirstIteration) {
-                output = await reduceFn(output, item, index, this);
+    reduce(reduceFn, initialValue) {
+        return new LazyPromise(async () => {
+            if (initialValue === undefined && (await this.isEmpty())) {
+                throw new TypeCollectionError("Reduce of empty array must be inputed a initial value");
             }
-            isFirstIteration = false;
-            index++;
-        }
-        return output;
-    }
-    async join(separator = ",") {
-        let str = null;
-        for await (const item of this) {
-            if (typeof item !== "string") {
-                throw new TypeCollectionError("Item type is invalid must be string");
+            if (initialValue !== undefined) {
+                let output = initialValue;
+                for await (const [index, item] of this.entries()) {
+                    output = await reduceFn(output, item, index, this);
+                }
+                return output;
             }
-            if (str === null) {
-                str = item;
+            let output = (await this.firstOrFail()), index = 0, isFirstIteration = true;
+            for await (const item of this) {
+                if (!isFirstIteration) {
+                    output = await reduceFn(output, item, index, this);
+                }
+                isFirstIteration = false;
+                index++;
             }
-            else {
-                str = str + separator + item;
+            return output;
+        });
+    }
+    join(separator = ",") {
+        return new LazyPromise(async () => {
+            let str = null;
+            for await (const item of this) {
+                if (typeof item !== "string") {
+                    throw new TypeCollectionError("Item type is invalid must be string");
+                }
+                if (str === null) {
+                    str = item;
+                }
+                else {
+                    str = str + separator + item;
+                }
             }
-        }
-        return str;
+            return str;
+        });
     }
     collapse() {
         return new AsyncIterableCollection(new AsyncCollapseIterable(this));
@@ -85,8 +91,8 @@ export class AsyncIterableCollection {
         }
         return this.skip((page - 1) * pageSize).take(pageSize);
     }
-    async sum() {
-        try {
+    sum() {
+        return new LazyPromise(async () => {
             if (await this.isEmpty()) {
                 throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
@@ -98,16 +104,10 @@ export class AsyncIterableCollection {
                 sum += item;
             }
             return sum;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async average() {
-        try {
+    average() {
+        return new LazyPromise(async () => {
             if (await this.isEmpty()) {
                 throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
@@ -120,53 +120,49 @@ export class AsyncIterableCollection {
                 sum += item;
             }
             return (sum / size);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async median() {
-        if (await this.isEmpty()) {
-            throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
-        }
-        const size = await this.size();
-        if (size === 0) {
-            return 0;
-        }
-        const isEven = size % 2 === 0, items = await this.map((item) => {
-            if (typeof item !== "number") {
-                throw new TypeCollectionError("Item type is invalid must be number");
+    median() {
+        return new LazyPromise(async () => {
+            if (await this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
-            return item;
-        })
-            .filter((_item, index) => {
+            const size = await this.size();
+            if (size === 0) {
+                return 0;
+            }
+            const isEven = size % 2 === 0, items = await this.map((item) => {
+                if (typeof item !== "number") {
+                    throw new TypeCollectionError("Item type is invalid must be number");
+                }
+                return item;
+            })
+                .filter((_item, index) => {
+                if (isEven) {
+                    return index === size / 2 || index === size / 2 - 1;
+                }
+                return index === Math.floor(size / 2);
+            })
+                .toArray();
             if (isEven) {
-                return index === size / 2 || index === size / 2 - 1;
-            }
-            return index === Math.floor(size / 2);
-        })
-            .toArray();
-        if (isEven) {
-            const [a, b] = items;
-            if (a === undefined) {
-                throw new UnexpectedCollectionError("Is in invalid state");
+                const [a, b] = items;
+                if (a === undefined) {
+                    throw new UnexpectedCollectionError("Is in invalid state");
+                }
+                if (b === undefined) {
+                    throw new UnexpectedCollectionError("Is in invalid state");
+                }
+                return ((a + b) / 2);
             }
-            if (b === undefined) {
+            const [median] = items;
+            if (median === undefined) {
                 throw new UnexpectedCollectionError("Is in invalid state");
             }
-            return ((a + b) / 2);
-        }
-        const [median] = items;
-        if (median === undefined) {
-            throw new UnexpectedCollectionError("Is in invalid state");
-        }
-        return median;
+            return median;
+        });
     }
-    async min() {
-        try {
+    min() {
+        return new LazyPromise(async () => {
             if (await this.isEmpty()) {
                 throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
@@ -183,16 +179,10 @@ export class AsyncIterableCollection {
                 }
             }
             return min;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async max() {
-        try {
+    max() {
+        return new LazyPromise(async () => {
             if (await this.isEmpty()) {
                 throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
@@ -209,16 +199,10 @@ export class AsyncIterableCollection {
                 }
             }
             return max;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async percentage(predicateFn) {
-        try {
+    percentage(predicateFn) {
+        return new LazyPromise(async () => {
             if (await this.isEmpty()) {
                 throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
@@ -230,32 +214,20 @@ export class AsyncIterableCollection {
                 total++;
             }
             return (part / total) * 100;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async some(predicateFn) {
-        try {
+    some(predicateFn) {
+        return new LazyPromise(async () => {
             for await (const [index, item] of this.entries()) {
                 if (await predicateFn(item, index, this)) {
                     return true;
                 }
             }
             return false;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async every(predicateFn) {
-        try {
+    every(predicateFn) {
+        return new LazyPromise(async () => {
             let isTrue = true;
             for await (const [index, item] of this.entries()) {
                 isTrue &&= await predicateFn(item, index, this);
@@ -264,13 +236,7 @@ export class AsyncIterableCollection {
                 }
             }
             return isTrue;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
     take(limit) {
         return new AsyncIterableCollection(new AsyncTakeIterable(this, limit));
@@ -302,16 +268,10 @@ export class AsyncIterableCollection {
     whenNotEmpty(callback) {
         return new AsyncIterableCollection(new AsyncWhenIterable(this, () => this.isNotEmpty(), callback));
     }
-    async pipe(callback) {
-        try {
+    pipe(callback) {
+        return new LazyPromise(async () => {
             return await callback(this);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
     tap(callback) {
         return new AsyncIterableCollection(new AsyncTapIterable(this, callback));
@@ -388,37 +348,33 @@ export class AsyncIterableCollection {
     shuffle(mathRandom = Math.random) {
         return new AsyncIterableCollection(new AsyncShuffleIterable(this, mathRandom));
     }
-    async first(predicateFn) {
+    first(predicateFn) {
         return this.firstOr(null, predicateFn);
     }
-    async firstOr(defaultValue, predicateFn = () => true) {
-        try {
+    firstOr(defaultValue, predicateFn = () => true) {
+        return new LazyPromise(async () => {
             for await (const [index, item] of this.entries()) {
                 if (await predicateFn(item, index, this)) {
                     return item;
                 }
             }
             return await simplifyAsyncLazyable(defaultValue);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async firstOrFail(predicateFn) {
-        const item = await this.first(predicateFn);
-        if (item === null) {
-            throw new ItemNotFoundCollectionError("Item was not found");
-        }
-        return item;
+    firstOrFail(predicateFn) {
+        return new LazyPromise(async () => {
+            const item = await this.first(predicateFn);
+            if (item === null) {
+                throw new ItemNotFoundCollectionError("Item was not found");
+            }
+            return item;
+        });
     }
-    async last(predicateFn) {
+    last(predicateFn) {
         return this.lastOr(null, predicateFn);
     }
-    async lastOr(defaultValue, predicateFn = () => true) {
-        try {
+    lastOr(defaultValue, predicateFn = () => true) {
+        return new LazyPromise(async () => {
             let matchedItem = null;
             for await (const [index, item] of this.entries()) {
                 if (await predicateFn(item, index, this)) {
@@ -429,26 +385,22 @@ export class AsyncIterableCollection {
                 return matchedItem;
             }
             return await simplifyAsyncLazyable(defaultValue);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async lastOrFail(predicateFn) {
-        const item = await this.last(predicateFn);
-        if (item === null) {
-            throw new ItemNotFoundCollectionError("Item was not found");
-        }
-        return item;
+    lastOrFail(predicateFn) {
+        return new LazyPromise(async () => {
+            const item = await this.last(predicateFn);
+            if (item === null) {
+                throw new ItemNotFoundCollectionError("Item was not found");
+            }
+            return item;
+        });
     }
-    async before(predicateFn) {
+    before(predicateFn) {
         return this.beforeOr(null, predicateFn);
     }
-    async beforeOr(defaultValue, predicateFn) {
-        try {
+    beforeOr(defaultValue, predicateFn) {
+        return new LazyPromise(async () => {
             let beforeItem = null, index = 0;
             for await (const item of this) {
                 if ((await predicateFn(item, index, this)) && beforeItem) {
@@ -458,26 +410,22 @@ export class AsyncIterableCollection {
                 beforeItem = item;
             }
             return await simplifyAsyncLazyable(defaultValue);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async beforeOrFail(predicateFn) {
-        const item = await this.before(predicateFn);
-        if (item === null) {
-            throw new ItemNotFoundCollectionError("Item was not found");
-        }
-        return item;
+    beforeOrFail(predicateFn) {
+        return new LazyPromise(async () => {
+            const item = await this.before(predicateFn);
+            if (item === null) {
+                throw new ItemNotFoundCollectionError("Item was not found");
+            }
+            return item;
+        });
     }
-    async after(predicateFn) {
+    after(predicateFn) {
         return this.afterOr(null, predicateFn);
     }
-    async afterOr(defaultValue, predicateFn) {
-        try {
+    afterOr(defaultValue, predicateFn) {
+        return new LazyPromise(async () => {
             let hasMatched = false, index = 0;
             for await (const item of this) {
                 if (hasMatched) {
@@ -487,23 +435,19 @@ export class AsyncIterableCollection {
                 index++;
             }
             return await simplifyAsyncLazyable(defaultValue);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError("!!__messge__!!", error);
-        }
+        });
     }
-    async afterOrFail(predicateFn) {
-        const item = await this.after(predicateFn);
-        if (item === null) {
-            throw new ItemNotFoundCollectionError("Item was not found");
-        }
-        return item;
+    afterOrFail(predicateFn) {
+        return new LazyPromise(async () => {
+            const item = await this.after(predicateFn);
+            if (item === null) {
+                throw new ItemNotFoundCollectionError("Item was not found");
+            }
+            return item;
+        });
     }
-    async sole(predicateFn) {
-        try {
+    sole(predicateFn) {
+        return new LazyPromise(async () => {
             let matchedItem = null;
             for await (const [index, item] of this.entries()) {
                 if (await predicateFn(item, index, this)) {
@@ -517,28 +461,22 @@ export class AsyncIterableCollection {
                 throw new ItemNotFoundCollectionError("Item was not found");
             }
             return matchedItem;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
     nth(step) {
         return this.filter((_item, index) => index % step === 0);
     }
-    delay(timeInMs) {
-        return new AsyncIterableCollection(new AsyncDelayIterable(this, timeInMs));
+    delay(time) {
+        return new AsyncIterableCollection(delayIterable(this, time));
     }
-    abort(signal) {
-        return new AsyncIterableCollection(new AsyncAbortIterable(this, signal));
+    takeUntilAbort(abortSignal) {
+        return new AsyncIterableCollection(new AsyncErrorHandlerIterable(abortableIterable(this, abortSignal), (error) => error instanceof AbortAsyncError));
     }
-    timeout(timeInMs) {
-        return new AsyncIterableCollection(new AsyncTimeoutIterable(this, timeInMs));
+    takeUntilTimeout(timeInMs) {
+        return new AsyncIterableCollection(new AsyncErrorHandlerIterable(timeoutIterable(this, timeInMs), (error) => error instanceof TimeoutAsyncError));
     }
-    async count(predicateFn) {
-        try {
+    count(predicateFn) {
+        return new LazyPromise(async () => {
             let size = 0;
             for await (const item of this) {
                 if (await predicateFn(item, size, this)) {
@@ -546,52 +484,36 @@ export class AsyncIterableCollection {
                 }
             }
             return size;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async size() {
+    size() {
         return this.count(() => true);
     }
-    async isEmpty() {
-        try {
+    isEmpty() {
+        return new LazyPromise(async () => {
             for await (const _ of this) {
                 return false;
             }
             return true;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async isNotEmpty() {
-        return !(await this.isEmpty());
+    isNotEmpty() {
+        return new LazyPromise(async () => {
+            return !(await this.isEmpty());
+        });
     }
-    async searchFirst(predicateFn) {
-        try {
+    searchFirst(predicateFn) {
+        return new LazyPromise(async () => {
             for await (const [index, item] of this.entries()) {
                 if (await predicateFn(item, index, this)) {
                     return index;
                 }
             }
             return -1;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async searchLast(predicateFn) {
-        try {
+    searchLast(predicateFn) {
+        return new LazyPromise(async () => {
             let matchedIndex = -1;
             for await (const [index, item] of this.entries()) {
                 if (await predicateFn(item, index, this)) {
@@ -599,33 +521,23 @@ export class AsyncIterableCollection {
                 }
             }
             return matchedIndex;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async forEach(callback) {
-        for await (const [index, item] of this.entries()) {
-            await callback(item, index, this);
-        }
+    forEach(callback) {
+        return new LazyPromise(async () => {
+            for await (const [index, item] of this.entries()) {
+                await callback(item, index, this);
+            }
+        });
     }
-    async toArray() {
-        try {
+    toArray() {
+        return new LazyPromise(async () => {
             const items = [];
             for await (const item of this) {
                 items.push(item);
             }
             return items;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
 }
 //# sourceMappingURL=async-iterable-collection.js.map