@daiso-tech/core 0.4.0 → 0.5.0

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

@@ -4,6 +4,8 @@ exports.AsyncIterableCollection = void 0;
 const _module_1 = require("../../contracts/collection/_module");
 const _module_2 = require("../../collection/async-iterable-collection/_shared/_module");
 const utilities_1 = require("../../_shared/utilities");
+const _module_3 = require("../../_module");
+const _module_4 = require("../../async/_module");
 class AsyncIterableCollection {
     iterable;
     static DEFAULT_CHUNK_SIZE = 1024;
@@ -37,41 +39,45 @@ class AsyncIterableCollection {
     map(mapFn) {
         return new AsyncIterableCollection(new _module_2.AsyncMapIterable(this, mapFn));
     }
-    async reduce(reduceFn, initialValue) {
-        if (initialValue === undefined && (await this.isEmpty())) {
-            throw new _module_1.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 _module_3.LazyPromise(async () => {
+            if (initialValue === undefined && (await this.isEmpty())) {
+                throw new _module_1.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 _module_1.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 _module_3.LazyPromise(async () => {
+            let str = null;
+            for await (const item of this) {
+                if (typeof item !== "string") {
+                    throw new _module_1.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 _module_2.AsyncCollapseIterable(this));
@@ -88,8 +94,8 @@ class AsyncIterableCollection {
         }
         return this.skip((page - 1) * pageSize).take(pageSize);
     }
-    async sum() {
-        try {
+    sum() {
+        return new _module_3.LazyPromise(async () => {
             if (await this.isEmpty()) {
                 throw new _module_1.EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
@@ -101,16 +107,10 @@ class AsyncIterableCollection {
                 sum += item;
             }
             return sum;
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async average() {
-        try {
+    average() {
+        return new _module_3.LazyPromise(async () => {
             if (await this.isEmpty()) {
                 throw new _module_1.EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
@@ -123,53 +123,49 @@ class AsyncIterableCollection {
                 sum += item;
             }
             return (sum / size);
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async median() {
-        if (await this.isEmpty()) {
-            throw new _module_1.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 _module_1.TypeCollectionError("Item type is invalid must be number");
+    median() {
+        return new _module_3.LazyPromise(async () => {
+            if (await this.isEmpty()) {
+                throw new _module_1.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 _module_1.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 _module_1.UnexpectedCollectionError("Is in invalid state");
+                const [a, b] = items;
+                if (a === undefined) {
+                    throw new _module_1.UnexpectedCollectionError("Is in invalid state");
+                }
+                if (b === undefined) {
+                    throw new _module_1.UnexpectedCollectionError("Is in invalid state");
+                }
+                return ((a + b) / 2);
             }
-            if (b === undefined) {
+            const [median] = items;
+            if (median === undefined) {
                 throw new _module_1.UnexpectedCollectionError("Is in invalid state");
             }
-            return ((a + b) / 2);
-        }
-        const [median] = items;
-        if (median === undefined) {
-            throw new _module_1.UnexpectedCollectionError("Is in invalid state");
-        }
-        return median;
+            return median;
+        });
     }
-    async min() {
-        try {
+    min() {
+        return new _module_3.LazyPromise(async () => {
             if (await this.isEmpty()) {
                 throw new _module_1.EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
@@ -186,16 +182,10 @@ class AsyncIterableCollection {
                 }
             }
             return min;
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async max() {
-        try {
+    max() {
+        return new _module_3.LazyPromise(async () => {
             if (await this.isEmpty()) {
                 throw new _module_1.EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
@@ -212,16 +202,10 @@ class AsyncIterableCollection {
                 }
             }
             return max;
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async percentage(predicateFn) {
-        try {
+    percentage(predicateFn) {
+        return new _module_3.LazyPromise(async () => {
             if (await this.isEmpty()) {
                 throw new _module_1.EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
@@ -233,32 +217,20 @@ class AsyncIterableCollection {
                 total++;
             }
             return (part / total) * 100;
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async some(predicateFn) {
-        try {
+    some(predicateFn) {
+        return new _module_3.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 _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async every(predicateFn) {
-        try {
+    every(predicateFn) {
+        return new _module_3.LazyPromise(async () => {
             let isTrue = true;
             for await (const [index, item] of this.entries()) {
                 isTrue &&= await predicateFn(item, index, this);
@@ -267,13 +239,7 @@ class AsyncIterableCollection {
                 }
             }
             return isTrue;
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
     take(limit) {
         return new AsyncIterableCollection(new _module_2.AsyncTakeIterable(this, limit));
@@ -305,16 +271,10 @@ class AsyncIterableCollection {
     whenNotEmpty(callback) {
         return new AsyncIterableCollection(new _module_2.AsyncWhenIterable(this, () => this.isNotEmpty(), callback));
     }
-    async pipe(callback) {
-        try {
+    pipe(callback) {
+        return new _module_3.LazyPromise(async () => {
             return await callback(this);
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
     tap(callback) {
         return new AsyncIterableCollection(new _module_2.AsyncTapIterable(this, callback));
@@ -391,37 +351,33 @@ class AsyncIterableCollection {
     shuffle(mathRandom = Math.random) {
         return new AsyncIterableCollection(new _module_2.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 _module_3.LazyPromise(async () => {
             for await (const [index, item] of this.entries()) {
                 if (await predicateFn(item, index, this)) {
                     return item;
                 }
             }
             return await (0, utilities_1.simplifyAsyncLazyable)(defaultValue);
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async firstOrFail(predicateFn) {
-        const item = await this.first(predicateFn);
-        if (item === null) {
-            throw new _module_1.ItemNotFoundCollectionError("Item was not found");
-        }
-        return item;
+    firstOrFail(predicateFn) {
+        return new _module_3.LazyPromise(async () => {
+            const item = await this.first(predicateFn);
+            if (item === null) {
+                throw new _module_1.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 _module_3.LazyPromise(async () => {
             let matchedItem = null;
             for await (const [index, item] of this.entries()) {
                 if (await predicateFn(item, index, this)) {
@@ -432,26 +388,22 @@ class AsyncIterableCollection {
                 return matchedItem;
             }
             return await (0, utilities_1.simplifyAsyncLazyable)(defaultValue);
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async lastOrFail(predicateFn) {
-        const item = await this.last(predicateFn);
-        if (item === null) {
-            throw new _module_1.ItemNotFoundCollectionError("Item was not found");
-        }
-        return item;
+    lastOrFail(predicateFn) {
+        return new _module_3.LazyPromise(async () => {
+            const item = await this.last(predicateFn);
+            if (item === null) {
+                throw new _module_1.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 _module_3.LazyPromise(async () => {
             let beforeItem = null, index = 0;
             for await (const item of this) {
                 if ((await predicateFn(item, index, this)) && beforeItem) {
@@ -461,26 +413,22 @@ class AsyncIterableCollection {
                 beforeItem = item;
             }
             return await (0, utilities_1.simplifyAsyncLazyable)(defaultValue);
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async beforeOrFail(predicateFn) {
-        const item = await this.before(predicateFn);
-        if (item === null) {
-            throw new _module_1.ItemNotFoundCollectionError("Item was not found");
-        }
-        return item;
+    beforeOrFail(predicateFn) {
+        return new _module_3.LazyPromise(async () => {
+            const item = await this.before(predicateFn);
+            if (item === null) {
+                throw new _module_1.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 _module_3.LazyPromise(async () => {
             let hasMatched = false, index = 0;
             for await (const item of this) {
                 if (hasMatched) {
@@ -490,23 +438,19 @@ class AsyncIterableCollection {
                 index++;
             }
             return await (0, utilities_1.simplifyAsyncLazyable)(defaultValue);
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError("!!__messge__!!", error);
-        }
+        });
     }
-    async afterOrFail(predicateFn) {
-        const item = await this.after(predicateFn);
-        if (item === null) {
-            throw new _module_1.ItemNotFoundCollectionError("Item was not found");
-        }
-        return item;
+    afterOrFail(predicateFn) {
+        return new _module_3.LazyPromise(async () => {
+            const item = await this.after(predicateFn);
+            if (item === null) {
+                throw new _module_1.ItemNotFoundCollectionError("Item was not found");
+            }
+            return item;
+        });
     }
-    async sole(predicateFn) {
-        try {
+    sole(predicateFn) {
+        return new _module_3.LazyPromise(async () => {
             let matchedItem = null;
             for await (const [index, item] of this.entries()) {
                 if (await predicateFn(item, index, this)) {
@@ -520,28 +464,22 @@ class AsyncIterableCollection {
                 throw new _module_1.ItemNotFoundCollectionError("Item was not found");
             }
             return matchedItem;
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
     nth(step) {
         return this.filter((_item, index) => index % step === 0);
     }
-    delay(timeInMs) {
-        return new AsyncIterableCollection(new _module_2.AsyncDelayIterable(this, timeInMs));
+    delay(time) {
+        return new AsyncIterableCollection((0, _module_3.delayIterable)(this, time));
     }
-    abort(signal) {
-        return new AsyncIterableCollection(new _module_2.AsyncAbortIterable(this, signal));
+    takeUntilAbort(abortSignal) {
+        return new AsyncIterableCollection(new _module_2.AsyncErrorHandlerIterable((0, _module_3.abortableIterable)(this, abortSignal), (error) => error instanceof _module_4.AbortAsyncError));
     }
-    timeout(timeInMs) {
-        return new AsyncIterableCollection(new _module_2.AsyncTimeoutIterable(this, timeInMs));
+    takeUntilTimeout(timeInMs) {
+        return new AsyncIterableCollection(new _module_2.AsyncErrorHandlerIterable((0, _module_4.timeoutIterable)(this, timeInMs), (error) => error instanceof _module_4.TimeoutAsyncError));
     }
-    async count(predicateFn) {
-        try {
+    count(predicateFn) {
+        return new _module_3.LazyPromise(async () => {
             let size = 0;
             for await (const item of this) {
                 if (await predicateFn(item, size, this)) {
@@ -549,52 +487,36 @@ class AsyncIterableCollection {
                 }
             }
             return size;
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async size() {
+    size() {
         return this.count(() => true);
     }
-    async isEmpty() {
-        try {
+    isEmpty() {
+        return new _module_3.LazyPromise(async () => {
             for await (const _ of this) {
                 return false;
             }
             return true;
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async isNotEmpty() {
-        return !(await this.isEmpty());
+    isNotEmpty() {
+        return new _module_3.LazyPromise(async () => {
+            return !(await this.isEmpty());
+        });
     }
-    async searchFirst(predicateFn) {
-        try {
+    searchFirst(predicateFn) {
+        return new _module_3.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 _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
-    async searchLast(predicateFn) {
-        try {
+    searchLast(predicateFn) {
+        return new _module_3.LazyPromise(async () => {
             let matchedIndex = -1;
             for await (const [index, item] of this.entries()) {
                 if (await predicateFn(item, index, this)) {
@@ -602,33 +524,23 @@ class AsyncIterableCollection {
                 }
             }
             return matchedIndex;
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.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 _module_3.LazyPromise(async () => {
+            for await (const [index, item] of this.entries()) {
+                await callback(item, index, this);
+            }
+        });
     }
-    async toArray() {
-        try {
+    toArray() {
+        return new _module_3.LazyPromise(async () => {
             const items = [];
             for await (const item of this) {
                 items.push(item);
             }
             return items;
-        }
-        catch (error) {
-            if (error instanceof _module_1.CollectionError) {
-                throw error;
-            }
-            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
 }
 exports.AsyncIterableCollection = AsyncIterableCollection;