@daiso-tech/core 0.0.1

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

@@ -0,0 +1,32 @@
+export * from "@/collection/iterable-collection/iterable-helpers/chunk-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/chunk-whilte-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/collapse-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/count-by-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/cross-join-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/entries-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/filter-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/flat-map-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/group-by-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/insert-after-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/insert-before-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/map-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/merge-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/pad-end-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/pad-start-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/partion-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/repeat-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/reverse-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/shuffle-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/skip-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/skip-until-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/slice-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/sliding-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/sort-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/split-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/take-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/take-until-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/tap-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/unique-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/update-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/when-iterable";
+export * from "@/collection/iterable-collection/iterable-helpers/zip-iterable";

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

@@ -0,0 +1,49 @@
+import {
+    CollectionError,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class ChunkIterable<TInput> implements Iterable<ICollection<TInput>> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private chunkSize: number,
+        private readonly makeCollection: <TInput>(
+            iterable: Iterable<TInput>,
+        ) => ICollection<TInput>,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<ICollection<TInput>> {
+        try {
+            let chunk: ICollection<TInput> = this.makeCollection<TInput>([]),
+                currentChunkSize = 0,
+                isFirstIteration = true;
+            for (const item of this.collection) {
+                currentChunkSize %= this.chunkSize;
+                const isFilled = currentChunkSize === 0;
+                if (!isFirstIteration && isFilled) {
+                    yield chunk;
+                    chunk = this.makeCollection<TInput>([]);
+                }
+                chunk = chunk.append([item]);
+                currentChunkSize++;
+                isFirstIteration = false;
+            }
+            const hasRest = currentChunkSize !== 0;
+            if (hasRest) {
+                yield chunk;
+            }
+        } 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/chunk-whilte-iterable.ts

@@ -0,0 +1,51 @@
+import {
+    CollectionError,
+    type Filter,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class ChunkWhileIterable<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 collection: ICollection<TInput> = this.makeCollection<TInput>(
+                [],
+            );
+            for (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                if (index === 0) {
+                    collection = collection.append([item]);
+                } else if (this.filter(item, index, collection)) {
+                    collection = collection.append([item]);
+                } else {
+                    yield collection;
+                    collection = this.makeCollection<TInput>([item]);
+                }
+            }
+            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/collapse-iterable.ts

@@ -0,0 +1,35 @@
+import { isIterable } from "@/collection/_shared";
+import {
+    type Collapse,
+    CollectionError,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class CollapseIterable<TInput> implements Iterable<Collapse<TInput>> {
+    constructor(private collection: ICollection<TInput>) {}
+
+    *[Symbol.iterator](): Iterator<Collapse<TInput>> {
+        try {
+            for (const item of this.collection) {
+                if (isIterable<TInput>(item)) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    yield* item as any;
+                } else {
+                    yield item as Collapse<TInput>;
+                }
+            }
+        } 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/count-by-iterable.ts

@@ -0,0 +1,49 @@
+import {
+    CollectionError,
+    type ICollection,
+    type Map,
+    type RecordItem,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class CountByIterable<TInput, TOutput = TInput>
+    implements Iterable<RecordItem<TOutput, number>>
+{
+    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<RecordItem<TOutput, number>> {
+        try {
+            const map = new Map<TOutput, number>();
+            for (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                const key = this.callback(item, index, this.collection);
+                if (!map.has(key)) {
+                    map.set(key, 0);
+                }
+                const counter = map.get(key);
+                if (counter !== undefined) {
+                    map.set(key, counter + 1);
+                }
+            }
+            yield* map;
+        } 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/cross-join-iterable.ts

@@ -0,0 +1,57 @@
+import {
+    CollectionError,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class CrossJoinIterable<TInput, TExtended = TInput>
+    implements Iterable<ICollection<TInput | TExtended>>
+{
+    constructor(
+        private collection: ICollection<TInput>,
+        private iterables: Array<Iterable<TExtended>>,
+        private makeCollection: <TInput>(
+            iterable: Iterable<TInput>,
+        ) => ICollection<TInput>,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<ICollection<TInput | TExtended>> {
+        try {
+            yield* this.makeCollection<ICollection<TInput | TExtended>>([
+                this.collection,
+                ...this.iterables.map<ICollection<TExtended>>((iterable) =>
+                    this.makeCollection(iterable),
+                ),
+            ]).reduce<ICollection<ICollection<TInput | TExtended>>>({
+                reduceFn: (a, b) => {
+                    return a
+                        .map((x) =>
+                            b.map((y) => {
+                                return x.append([y]);
+                            }),
+                        )
+                        .reduce<ICollection<ICollection<TInput | TExtended>>>({
+                            reduceFn: (c, b) => c.append(b),
+                            initialValue: this.makeCollection<
+                                ICollection<TInput | TExtended>
+                            >([]),
+                        });
+                },
+                initialValue: this.makeCollection<
+                    ICollection<TInput | TExtended>
+                >([this.makeCollection<TInput | TExtended>([])]),
+            });
+        } 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/entries-iterable.ts

@@ -0,0 +1,42 @@
+import {
+    type RecordItem,
+    CollectionError,
+    IndexOverflowError,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_shared";
+
+export class EntriesIterable<TInput>
+    implements Iterable<RecordItem<number, TInput>>
+{
+    constructor(
+        private iterable: Iterable<TInput>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<RecordItem<number, TInput>> {
+        try {
+            let index = 0;
+            for (const item of this.iterable) {
+                if (
+                    this.throwOnNumberLimit &&
+                    index === Number.MAX_SAFE_INTEGER
+                ) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                yield [index, 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/iterable-collection/iterable-helpers/filter-iterable.ts

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

@@ -0,0 +1,35 @@
+import {
+    CollectionError,
+    type ICollection,
+    type Map,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class FlatMapIterable<TInput, TOutput> implements Iterable<TOutput> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private map: Map<TInput, ICollection<TInput>, Iterable<TOutput>>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TOutput> {
+        try {
+            for (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/iterable-collection/iterable-helpers/group-by-iterable.ts

@@ -0,0 +1,52 @@
+import {
+    CollectionError,
+    UnexpectedCollectionError,
+    type ICollection,
+    type Map,
+    type RecordItem,
+} from "@/contracts/collection/_module";
+
+export class GroupByIterable<TInput, TOutput = TInput>
+    implements Iterable<RecordItem<TOutput, ICollection<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,
+        private makeCollection: <TInput>(
+            iterable: Iterable<TInput>,
+        ) => ICollection<TInput>,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<RecordItem<TOutput, ICollection<TInput>>> {
+        try {
+            const map = new Map<TOutput, ICollection<TInput>>();
+            for (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                const key = this.callback(item, index, this.collection);
+                let collection: ICollection<TInput> | undefined = map.get(key);
+                if (collection === undefined) {
+                    collection = this.makeCollection<TInput>([]);
+                    map.set(key, collection);
+                }
+
+                map.set(key, collection.append([item]));
+            }
+            yield* map;
+        } 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/insert-after-iterable.ts

@@ -0,0 +1,43 @@
+import {
+    CollectionError,
+    type Filter,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class InsertAfterIterable<TInput, TExtended>
+    implements Iterable<TInput | TExtended>
+{
+    constructor(
+        private collection: ICollection<TInput>,
+        private filter: Filter<TInput, ICollection<TInput>>,
+        private iterable: Iterable<TInput | TExtended>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput | TExtended> {
+        try {
+            let hasMatched = false;
+            for (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                yield item;
+                if (!hasMatched && this.filter(item, index, this.collection)) {
+                    yield* this.iterable;
+                    hasMatched = true;
+                }
+            }
+        } 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/insert-before-iterable.ts

@@ -0,0 +1,43 @@
+import {
+    CollectionError,
+    type Filter,
+    type ICollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class InsertBeforeIterable<TInput, TExtended>
+    implements Iterable<TInput | TExtended>
+{
+    constructor(
+        private collection: ICollection<TInput>,
+        private filter: Filter<TInput, ICollection<TInput>>,
+        private iterable: Iterable<TInput | TExtended>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TInput | TExtended> {
+        try {
+            let hasMatched = false;
+            for (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                if (!hasMatched && this.filter(item, index, this.collection)) {
+                    yield* this.iterable;
+                    hasMatched = true;
+                }
+                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/map-iterable.ts

@@ -0,0 +1,35 @@
+import {
+    CollectionError,
+    type ICollection,
+    type Map,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class MapIterable<TInput, TOutput> implements Iterable<TOutput> {
+    constructor(
+        private collection: ICollection<TInput>,
+        private map: Map<TInput, ICollection<TInput>, TOutput>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<TOutput> {
+        try {
+            for (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/iterable-collection/iterable-helpers/merge-iterable.ts

@@ -0,0 +1,31 @@
+import {
+    CollectionError,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+export class MergeIterable<TInput, TExtended>
+    implements Iterable<TInput | TExtended>
+{
+    constructor(
+        private iterableA: Iterable<TInput>,
+        private iterableB: Iterable<TExtended>,
+    ) {}
+
+    *[Symbol.iterator](): Iterator<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/iterable-collection/iterable-helpers/pad-end-iterable.ts

@@ -0,0 +1,52 @@
+import {
+    CollectionError,
+    UnexpectedCollectionError,
+    type ICollection,
+} from "@/contracts/collection/_module";
+
+export class PadEndIterable<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.prepend(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,
+            );
+        }
+    }
+}