@daiso-tech/core 0.0.1

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

@@ -0,0 +1,52 @@
+import {
+    CollectionError,
+    UnexpectedCollectionError,
+    type ICollection,
+} from "@/contracts/collection/_module";
+
+export class PadStartIterable<TInput, TExtended>
+    implements Iterable<TInput | TExtended>
+{
+    constructor(
+        private collection: ICollection<TInput>,
+        private maxLength: number,
+        private fillItems: Iterable<TExtended>,
+        private makeCollection: <TInput>(
+            iterable: Iterable<TInput | TExtended>,
+        ) => ICollection<TInput | TExtended>,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput | TExtended> {
+        try {
+            const fillCollections = this.makeCollection<TInput>(this.fillItems);
+            const fillSize = fillCollections.size();
+            const size = this.collection.size();
+            const repeat = Math.floor((this.maxLength - size) / fillSize);
+            let resultCollection: ICollection<TInput | TExtended> =
+                this.makeCollection<TInput>([]);
+            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;
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

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

@@ -0,0 +1,46 @@
+import {
+    CollectionError,
+    type Filter,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class PartionIterable<TInput> implements Iterable<ICollection<TInput>> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private filter: Filter<TInput, ICollection<TInput>>,
+        private throwOnNumberLimit: boolean,
+        private makeCollection: <TInput>(
+            iterable: Iterable<TInput>,
+        ) => ICollection<TInput>,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<ICollection<TInput>> {
+        try {
+            let chunkA: ICollection<TInput> = this.makeCollection<TInput>([]),
+                chunkB: ICollection<TInput> = this.makeCollection<TInput>([]);
+            for (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                if (this.filter(item, index, this.collection)) {
+                    chunkA = chunkA.append([item]);
+                } else {
+                    chunkB = chunkB.append([item]);
+                }
+            }
+            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/iterable-collection/iterable-helpers/repeat-iterable.ts

@@ -0,0 +1,36 @@
+import {
+    CollectionError,
+    UnexpectedCollectionError,
+    type ICollection,
+} from "@/contracts/collection/_module";
+
+export class RepeatIterable<TInput> implements Iterable<TInput> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private amount: number,
+        private makeCollection: <TInput>(
+            iterable: Iterable<TInput>,
+        ) => ICollection<TInput>,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput> {
+        try {
+            let collection = this.makeCollection<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/iterable-collection/iterable-helpers/reverse-iterable.ts

@@ -0,0 +1,46 @@
+import {
+    CollectionError,
+    UnexpectedCollectionError,
+    type ICollection,
+} from "@/contracts/collection/_module";
+
+export class ReverseIterable<TInput> implements Iterable<TInput> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private chunkSize: number,
+        private throwOnNumberLimit: boolean,
+        private makeCollection: <TInput>(
+            iterable: Iterable<TInput>,
+        ) => ICollection<TInput>,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput> {
+        try {
+            const collection: ICollection<TInput> = this.makeCollection<TInput>(
+                [],
+            );
+            yield* this.collection
+                .chunk(this.chunkSize)
+                .map(
+                    (item) => this.makeCollection<TInput>([...item].reverse()),
+                    this.throwOnNumberLimit,
+                )
+                .reduce({
+                    reduceFn: (collection, item) => collection.prepend(item),
+                    initialValue: collection,
+                    throwOnNumberLimit: 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/iterable-collection/iterable-helpers/shuffle-iterable.ts

@@ -0,0 +1,36 @@
+import {
+    CollectionError,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_shared";
+
+export class ShuffleIterable<TInput> implements Iterable<TInput> {
+    constructor(private iterable: Iterable<TInput>) {}
+
+    *[Symbol.iterator](): Iterator<TInput> {
+        try {
+            const newArray = [...this.iterable];
+            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;
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+import {
+    CollectionError,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class SkipIterable<TInput> implements Iterable<TInput> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private offset: number,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput> {
+        try {
+            if (this.offset < 0) {
+                this.offset =
+                    this.collection.size(this.throwOnNumberLimit) + this.offset;
+            }
+            yield* this.collection.skipWhile(
+                (_item, index) => index < this.offset,
+                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/iterable-collection/iterable-helpers/skip-until-iterable.ts

@@ -0,0 +1,41 @@
+import {
+    CollectionError,
+    type Filter,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class SkipUntilIterable<TInput> implements Iterable<TInput> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private filter: Filter<TInput, ICollection<TInput>>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput> {
+        try {
+            let hasMatched = false;
+            for (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                if (!hasMatched) {
+                    hasMatched = this.filter(item, index, this.collection);
+                }
+                if (hasMatched) {
+                    yield item;
+                }
+            }
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+import {
+    CollectionError,
+    UnexpectedCollectionError,
+    type ICollection,
+} from "@/contracts/collection/_module";
+
+export class SliceIterable<TInput> implements Iterable<TInput> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private start: number | undefined,
+        private end: number | undefined,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput> {
+        try {
+            const size = 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);
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+import {
+    CollectionError,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class SlidingIteralbe<TInput> implements Iterable<ICollection<TInput>> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private chunkSize: number,
+        private step: number,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<ICollection<TInput>> {
+        try {
+            if (this.step <= 0) {
+                return;
+            }
+            const size = 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/iterable-collection/iterable-helpers/sort-iterable.ts

@@ -0,0 +1,29 @@
+import {
+    CollectionError,
+    UnexpectedCollectionError,
+    type Comparator,
+} from "@/contracts/collection/_module";
+
+export class SortIterable<TInput> implements Iterable<TInput> {
+    constructor(
+        private iterable: Iterable<TInput>,
+        private compare?: Comparator<TInput>,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput> {
+        try {
+            yield* [...this.iterable].sort(this.compare);
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

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

@@ -0,0 +1,58 @@
+import {
+    CollectionError,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class SplitIterable<TInput> implements Iterable<ICollection<TInput>> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private chunkAmount: number,
+        private throwOnNumberLimit: boolean,
+        private makeCollection: <TInput>(
+            iterable: Iterable<TInput>,
+        ) => ICollection<TInput>,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<ICollection<TInput>> {
+        try {
+            const size = 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: ICollection<TInput> =
+                    this.makeCollection<TInput>([]);
+                for (let i = 0; i < chunkSize; i++) {
+                    const item = 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/iterable-collection/iterable-helpers/take-iterable.ts

@@ -0,0 +1,37 @@
+import {
+    CollectionError,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class TakeIterable<TInput> implements Iterable<TInput> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private limit: number,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput> {
+        try {
+            if (this.limit < 0) {
+                this.limit =
+                    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/iterable-collection/iterable-helpers/take-until-iterable.ts

@@ -0,0 +1,38 @@
+import {
+    CollectionError,
+    type Filter,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class TakeUntilIterable<TInput> implements Iterable<TInput> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private filter: Filter<TInput, ICollection<TInput>>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput> {
+        try {
+            for (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                if (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,
+            );
+        }
+    }
+}

package/src/collection/iterable-collection/iterable-helpers/tap-iterable.ts

@@ -0,0 +1,31 @@
+import {
+    CollectionError,
+    type ICollection,
+    type Tap,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class TapIterable<TInput> implements Iterable<TInput> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private callback: Tap<ICollection<TInput>>,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput> {
+        try {
+            this.callback(this.collection);
+            yield* 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/iterable-collection/iterable-helpers/unique-iterable.ts

@@ -0,0 +1,43 @@
+import {
+    CollectionError,
+    type ICollection,
+    type Map,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class UniqueIterable<TInput, TOutput> implements Iterable<TInput> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private callback: Map<TInput, ICollection<TInput>, TOutput> = (item) =>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
+            item as any,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput> {
+        try {
+            const set = new Set<TOutput>([]);
+
+            for (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                const item_ = this.callback(item, index, this.collection);
+                if (!set.has(item_)) {
+                    yield item;
+                }
+                set.add(item_);
+            }
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}

package/src/collection/iterable-collection/iterable-helpers/update-iterable.ts

@@ -0,0 +1,50 @@
+import {
+    CollectionError,
+    type Filter,
+    type ICollection,
+    type Map,
+    UnexpectedCollectionError,
+    type UpdatedItem,
+} from "@/contracts/collection/_module";
+
+export class UpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput>
+    implements Iterable<UpdatedItem<TInput, TFilterOutput, TMapOutput>>
+{
+    constructor(
+        private collection: ICollection<TInput>,
+        private filter: Filter<TInput, ICollection<TInput>, TFilterOutput>,
+        private map: Map<TFilterOutput, ICollection<TInput>, TMapOutput>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<
+        UpdatedItem<TInput, TFilterOutput, TMapOutput>
+    > {
+        try {
+            for (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                if (this.filter(item, index, this.collection)) {
+                    yield this.map(
+                        item as TFilterOutput,
+                        index,
+                        this.collection,
+                    );
+                } else {
+                    yield item;
+                }
+            }
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}