@daiso-tech/core 0.0.1

package/src/collection/async-iterable-collection/async-iterable-helpers/async-map-iterable.ts

@@ -0,0 +1,40 @@
+import {
+    type AsyncMap,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncMapIterable<TInput, TOutput>
+    implements AsyncIterable<TOutput>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private map: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TOutput> {
+        try {
+            for await (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                yield this.map(item, index, this.collection);
+            }
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-merge-iterable.ts

@@ -0,0 +1,35 @@
+import {
+    type AsyncIterableValue,
+    CollectionError,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncMergeIterable<TInput, TExtended>
+    implements AsyncIterable<TInput | TExtended>
+{
+    constructor(
+        private iterableA: AsyncIterableValue<TInput>,
+        private iterableB: AsyncIterableValue<TExtended>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput | TExtended> {
+        try {
+            yield* this.iterableA;
+            yield* this.iterableB;
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-pad-end-iterable.ts

@@ -0,0 +1,41 @@
+import {
+    AsyncIterableValue,
+    type IAsyncCollection,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncPadEndIterable<TInput, TExtended>
+    implements AsyncIterable<TInput | TExtended>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private maxLength: number,
+        private fillItems: AsyncIterableValue<TExtended>,
+        private makeCollection: <TInput>(
+            iterable: AsyncIterableValue<TInput>,
+        ) => IAsyncCollection<TInput>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput | TExtended> {
+        const fillCollections = this.makeCollection(this.fillItems);
+        const fillSize = await fillCollections.size();
+        const size = await this.collection.size();
+        const repeat = Math.floor((this.maxLength - size) / fillSize);
+        let resultCollection: IAsyncCollection<TInput | TExtended> =
+            this.makeCollection<TInput | TExtended>([]);
+        for (let index = 0; index < repeat; index++) {
+            resultCollection = resultCollection.append(fillCollections);
+        }
+        const restAmount = this.maxLength - (repeat * fillSize + size);
+        resultCollection = resultCollection.append(
+            fillCollections.slice({
+                start: 0,
+                end: restAmount,
+            }),
+        );
+        resultCollection = resultCollection.prepend(this.collection);
+        yield* resultCollection;
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-pad-start-iterable.ts

@@ -0,0 +1,41 @@
+import {
+    AsyncIterableValue,
+    type IAsyncCollection,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncPadStartIterable<TInput, TExtended>
+    implements AsyncIterable<TInput | TExtended>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private maxLength: number,
+        private fillItems: AsyncIterableValue<TExtended>,
+        private makeCollection: <TInput>(
+            iterable: AsyncIterableValue<TInput>,
+        ) => IAsyncCollection<TInput>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput | TExtended> {
+        const fillCollections = this.makeCollection(this.fillItems);
+        const fillSize = await fillCollections.size();
+        const size = await this.collection.size();
+        const repeat = Math.floor((this.maxLength - size) / fillSize);
+        let resultCollection: IAsyncCollection<TInput | TExtended> =
+            this.makeCollection<TInput | TExtended>([]);
+        for (let index = 0; index < repeat; index++) {
+            resultCollection = resultCollection.append(fillCollections);
+        }
+        const restAmount = this.maxLength - (repeat * fillSize + size);
+        resultCollection = resultCollection.append(
+            fillCollections.slice({
+                start: 0,
+                end: restAmount,
+            }),
+        );
+        resultCollection = resultCollection.append(this.collection);
+        yield* resultCollection;
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-partion-iterable.ts

@@ -0,0 +1,63 @@
+import {
+    type AsyncFilter,
+    type AsyncIterableValue,
+    CollectionError,
+    type IAsyncCollection,
+    IndexOverflowError,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncPartionIterable<TInput>
+    implements AsyncIterable<IAsyncCollection<TInput>>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private filter: AsyncFilter<TInput, IAsyncCollection<TInput>>,
+        private throwOnNumberLimit: boolean,
+        private makeCollection: <TInput>(
+            iterable: AsyncIterableValue<TInput>,
+        ) => IAsyncCollection<TInput>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<IAsyncCollection<TInput>> {
+        try {
+            let chunkA: IAsyncCollection<TInput> = this.makeCollection<TInput>(
+                    [],
+                ),
+                chunkB: IAsyncCollection<TInput> = this.makeCollection<TInput>(
+                    [],
+                ),
+                index = 0;
+            for await (const item of this.collection) {
+                if (
+                    this.throwOnNumberLimit &&
+                    index === Number.MAX_SAFE_INTEGER
+                ) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                if (await this.filter(item, index, this.collection)) {
+                    chunkA = chunkA.append([item]);
+                } else {
+                    chunkB = chunkB.append([item]);
+                }
+                index++;
+            }
+            yield chunkA;
+            yield chunkB;
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-repeat-iterable.ts

@@ -0,0 +1,40 @@
+import {
+    type AsyncIterableValue,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncRepeatIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private amount: number,
+        private makeAsyncCollection: <TInput>(
+            iterable: AsyncIterableValue<TInput>,
+        ) => IAsyncCollection<TInput>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        try {
+            let collection = this.makeAsyncCollection<TInput>([]);
+            for (let index = 0; index < this.amount - 1; index++) {
+                collection = collection.append(this.collection);
+            }
+            yield* collection;
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-reverse-iterable.ts

@@ -0,0 +1,35 @@
+import {
+    type AsyncIterableValue,
+    type IAsyncCollection,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncReverseIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private chunkSize: number,
+        private throwOnNumberLimit: boolean,
+        private makeCollection: <TInput>(
+            iterable: AsyncIterableValue<TInput>,
+        ) => IAsyncCollection<TInput>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        const collection: IAsyncCollection<TInput> =
+            this.makeCollection<TInput>([]);
+        yield* await this.collection
+            .chunk(this.chunkSize)
+            .map(
+                async (item) =>
+                    this.makeCollection([...(await item.toArray())].reverse()),
+                this.throwOnNumberLimit,
+            )
+            .reduce({
+                reduceFn: (collection, item) => collection.prepend(item),
+                initialValue: collection,
+                throwOnNumberLimit: this.throwOnNumberLimit,
+            });
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-shuffle-iterable.ts

@@ -0,0 +1,23 @@
+import { type IAsyncCollection } from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncShuffleIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(private collection: IAsyncCollection<TInput>) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        const newArray = [...(await this.collection.toArray())];
+        for (let i = newArray.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            const temp = newArray[i];
+            if (newArray[j] !== undefined) {
+                newArray[i] = newArray[j];
+            }
+            if (temp !== undefined) {
+                newArray[j] = temp;
+            }
+        }
+        yield* newArray;
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-skip-iterable.ts

@@ -0,0 +1,41 @@
+import {
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncSkipIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private limit: number,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        try {
+            if (this.limit < 0) {
+                this.limit =
+                    (await this.collection.size(this.throwOnNumberLimit)) +
+                    this.limit;
+            }
+            yield* this.collection.skipWhile(
+                (_item, index) => index < this.limit,
+                this.throwOnNumberLimit,
+            );
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-skip-until-iterable.ts

@@ -0,0 +1,55 @@
+import {
+    type AsyncFilter,
+    CollectionError,
+    type IAsyncCollection,
+    IndexOverflowError,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncSkipUntilIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private filter: AsyncFilter<TInput, IAsyncCollection<TInput>>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        try {
+            let hasMatched = false,
+                index = 0;
+            for await (const item of this.collection) {
+                if (
+                    this.throwOnNumberLimit &&
+                    index === Number.MAX_SAFE_INTEGER
+                ) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                if (!hasMatched) {
+                    hasMatched = await this.filter(
+                        item,
+                        index,
+                        this.collection,
+                    );
+                }
+                if (hasMatched) {
+                    yield item;
+                }
+                index++;
+            }
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-slice-iterable.ts

@@ -0,0 +1,33 @@
+import { type IAsyncCollection } from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncSliceIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private start: number | undefined,
+        private end: number | undefined,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        const size = await this.collection.size();
+        let { start, end } = this;
+        if (start === undefined) {
+            start = 0;
+        }
+        if (end === undefined) {
+            end = size;
+        }
+        if (start < 0) {
+            start = size + start;
+        }
+        if (end < 0) {
+            end = size + end;
+        }
+        yield* this.collection.filter((_item, index) => {
+            return start <= index && index < end;
+        }, this.throwOnNumberLimit);
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-sliding-iterable.ts

@@ -0,0 +1,54 @@
+import {
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncSlidingIteralbe<TInput>
+    implements AsyncIterable<IAsyncCollection<TInput>>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private chunkSize: number,
+        private step: number,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<IAsyncCollection<TInput>> {
+        try {
+            if (this.step <= 0) {
+                return;
+            }
+            const size = await this.collection.size(this.throwOnNumberLimit);
+
+            for (let index = 0; index < size; index += this.step) {
+                const start = index;
+                const end = index + this.chunkSize;
+
+                yield this.collection.slice({
+                    start,
+                    end,
+                    throwOnNumberLimit: this.throwOnNumberLimit,
+                });
+
+                if (end >= size) {
+                    break;
+                }
+            }
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-sort-iterable.ts

@@ -0,0 +1,18 @@
+import {
+    type Comparator,
+    type IAsyncCollection,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncSortIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private compare?: Comparator<TInput>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        yield* [...(await this.collection.toArray())].sort(this.compare);
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-split-iterable.ts

@@ -0,0 +1,64 @@
+import {
+    type AsyncIterableValue,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncSplitIterable<TInput>
+    implements AsyncIterable<IAsyncCollection<TInput>>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private chunkAmount: number,
+        private throwOnNumberLimit: boolean,
+        private makeCollection: <TInput>(
+            iterable: AsyncIterableValue<TInput>,
+        ) => IAsyncCollection<TInput>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<IAsyncCollection<TInput>> {
+        try {
+            const size = await this.collection.size(this.throwOnNumberLimit),
+                minChunkSize = Math.floor(size / this.chunkAmount),
+                restSize = size % this.chunkAmount,
+                chunkSizes = Array.from<number>({
+                    length: this.chunkAmount,
+                }).fill(minChunkSize);
+
+            for (let i = 1; i <= restSize; i++) {
+                const chunkIndex = (i - 1) % this.chunkAmount;
+                if (chunkSizes[chunkIndex]) {
+                    chunkSizes[chunkIndex] = chunkSizes[chunkIndex] + 1;
+                }
+            }
+
+            const iterator = this.collection.iterator();
+            for (const chunkSize of chunkSizes) {
+                let collection: IAsyncCollection<TInput> =
+                    this.makeCollection<TInput>([]);
+                for (let i = 0; i < chunkSize; i++) {
+                    const item = await iterator.next();
+                    if (item.value !== undefined) {
+                        collection = collection.append([item.value]);
+                    }
+                }
+                yield collection;
+            }
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-take-iterable.ts

@@ -0,0 +1,41 @@
+import {
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncTakeIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private limit: number,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        try {
+            if (this.limit < 0) {
+                this.limit =
+                    (await this.collection.size(this.throwOnNumberLimit)) +
+                    this.limit;
+            }
+            yield* this.collection.takeWhile(
+                (_item, index) => index < this.limit,
+                this.throwOnNumberLimit,
+            );
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-take-until-iterable.ts

@@ -0,0 +1,41 @@
+import {
+    type AsyncFilter,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncTakeUntilIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private filter: AsyncFilter<TInput, IAsyncCollection<TInput>>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        try {
+            for await (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                if (await this.filter(item, index, this.collection)) {
+                    break;
+                }
+                yield item;
+            }
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}