@daiso-tech/core 0.0.1

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

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

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

@@ -0,0 +1,25 @@
+import { type IAsyncCollection } from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncAbortIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private signal: AbortSignal,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        let hasAborted = false;
+        this.signal.addEventListener("abort", () => {
+            hasAborted = true;
+        });
+        for await (const item of this.collection) {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (hasAborted) {
+                break;
+            }
+            yield item;
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+import {
+    type AsyncIterableValue,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncChunkIterable<TInput>
+    implements AsyncIterable<IAsyncCollection<TInput>>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private chunkSize: number,
+        private makeCollection: <TInput>(
+            iterable: AsyncIterableValue<TInput>,
+        ) => IAsyncCollection<TInput>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<IAsyncCollection<TInput>> {
+        try {
+            let chunk: IAsyncCollection<TInput> = this.makeCollection<TInput>(
+                    [],
+                ),
+                currentChunkSize = 0,
+                isFirstIteration = true;
+            for await (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/async-iterable-collection/async-iterable-helpers/async-chunk-whilte-iterable.ts

@@ -0,0 +1,54 @@
+import {
+    type AsyncFilter,
+    type AsyncIterableValue,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncChunkWhileIterable<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 collection: IAsyncCollection<TInput> =
+                this.makeCollection<TInput>([]);
+            for await (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                if (index === 0) {
+                    collection = collection.append([item]);
+                } else if (await 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/async-iterable-collection/async-iterable-helpers/async-collapse-iterable.ts

@@ -0,0 +1,40 @@
+import { isAsyncIterable, isIterable } from "@/collection/_shared";
+import {
+    type AsyncCollapse,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncCollapseIterable<TInput>
+    implements AsyncIterable<AsyncCollapse<TInput>>
+{
+    constructor(private collection: IAsyncCollection<TInput>) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<AsyncCollapse<TInput>> {
+        try {
+            for await (const item of this.collection) {
+                if (isIterable<TInput>(item) || isAsyncIterable<TInput>(item)) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    yield* item as any;
+                } else {
+                    yield item as AsyncCollapse<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/async-iterable-collection/async-iterable-helpers/async-count-by-iterable.ts

@@ -0,0 +1,58 @@
+import {
+    type AsyncMap,
+    CollectionError,
+    type IAsyncCollection,
+    type RecordItem,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncCountByIterable<TInput, TOutput = TInput>
+    implements AsyncIterable<RecordItem<TOutput, number>>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private callback: AsyncMap<
+            TInput,
+            IAsyncCollection<TInput>,
+            TOutput
+        > = (item) =>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
+            item as any,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<
+        RecordItem<TOutput, number>
+    > {
+        try {
+            const map = new Map<TOutput, number>();
+            for await (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                const key = await 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/async-iterable-collection/async-iterable-helpers/async-cross-join-iterable.ts

@@ -0,0 +1,69 @@
+import {
+    type AsyncIterableValue,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncCrossJoinIterable<TInput, TExtended>
+    implements AsyncIterable<IAsyncCollection<TInput | TExtended>>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private iterables: Array<AsyncIterableValue<TExtended>>,
+        private makeCollection: <TInput>(
+            iterable: AsyncIterableValue<TInput>,
+        ) => IAsyncCollection<TInput>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<
+        IAsyncCollection<TInput | TExtended>
+    > {
+        try {
+            yield* await this.makeCollection<
+                IAsyncCollection<TInput | TExtended>
+            >([
+                this.collection,
+                ...this.iterables.map<IAsyncCollection<TExtended>>((iterable) =>
+                    this.makeCollection(iterable),
+                ),
+            ]).reduce<IAsyncCollection<IAsyncCollection<TInput | TExtended>>>({
+                reduceFn: (a, b) => {
+                    return a
+                        .map((x) =>
+                            b.map((y) => {
+                                return x.append([y]);
+                            }),
+                        )
+                        .reduce<
+                            IAsyncCollection<
+                                IAsyncCollection<TInput | TExtended>
+                            >
+                        >({
+                            reduceFn: (c, b) => c.append(b),
+                            initialValue: this.makeCollection<
+                                IAsyncCollection<TInput | TExtended>
+                            >([]),
+                        });
+                },
+                initialValue: this.makeCollection<
+                    IAsyncCollection<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/async-iterable-collection/async-iterable-helpers/async-delay-iterable.ts

@@ -0,0 +1,19 @@
+import { type IAsyncCollection } from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncDelayIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private timeInMs: number,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        for await (const item of this.collection) {
+            yield item;
+
+            await new Promise((resolve) => setTimeout(resolve, this.timeInMs));
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+import {
+    type RecordItem,
+    IndexOverflowError,
+} from "@/contracts/collection/_shared";
+import type { AsyncIterableValue } from "@/contracts/collection/async-collection.contract";
+
+/**
+ * @internal
+ */
+export class AsyncEntriesIterable<TInput>
+    implements AsyncIterable<RecordItem<number, TInput>>
+{
+    constructor(
+        private iterable: AsyncIterableValue<TInput>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<RecordItem<number, TInput>> {
+        let index = 0;
+        for await (const item of this.iterable) {
+            if (this.throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                throw new IndexOverflowError("Index has overflowed");
+            }
+            yield [index, item];
+            index++;
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+import {
+    type AsyncFilter,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncFilterIterable<TInput, TOutput extends TInput>
+    implements AsyncIterable<TOutput>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private filter: AsyncFilter<TInput, IAsyncCollection<TInput>, TOutput>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TOutput> {
+        try {
+            for await (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                if (await 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/async-iterable-collection/async-iterable-helpers/async-flat-map-iterable.ts

@@ -0,0 +1,44 @@
+import {
+    type AsyncMap,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncFlatMapIterable<TInput, TOutput>
+    implements AsyncIterable<TOutput>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private map: AsyncMap<
+            TInput,
+            IAsyncCollection<TInput>,
+            Iterable<TOutput>
+        >,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TOutput> {
+        try {
+            for await (const [index, item] of this.collection.entries(
+                this.throwOnNumberLimit,
+            )) {
+                yield* await 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-group-by-iterable.ts

@@ -0,0 +1,48 @@
+import {
+    type AsyncIterableValue,
+    type AsyncMap,
+    type IAsyncCollection,
+    type RecordItem,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncGroupByIterable<TInput, TOutput = TInput>
+    implements AsyncIterable<RecordItem<TOutput, IAsyncCollection<TInput>>>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private callback: AsyncMap<
+            TInput,
+            IAsyncCollection<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: AsyncIterableValue<TInput>,
+        ) => IAsyncCollection<TInput>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<
+        RecordItem<TOutput, IAsyncCollection<TInput>>
+    > {
+        const map = new Map<TOutput, IAsyncCollection<TInput>>();
+
+        for await (const [index, item] of this.collection.entries(
+            this.throwOnNumberLimit,
+        )) {
+            const key = await this.callback(item, index, this.collection);
+            let collection: IAsyncCollection<TInput> | undefined = map.get(key);
+            if (collection === undefined) {
+                collection = this.makeCollection<TInput>([]);
+                map.set(key, collection);
+            }
+
+            map.set(key, collection.append([item]));
+        }
+        yield* map;
+    }
+}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-insert-after-iterable.ts

@@ -0,0 +1,57 @@
+import {
+    type AsyncFilter,
+    type AsyncIterableValue,
+    CollectionError,
+    type IAsyncCollection,
+    IndexOverflowError,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncInsertAfterIterable<TInput, TExtended>
+    implements AsyncIterable<TInput | TExtended>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private filter: AsyncFilter<TInput, IAsyncCollection<TInput>>,
+        private iterable: AsyncIterableValue<TInput | TExtended>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput | TExtended> {
+        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");
+                }
+                yield item;
+                if (
+                    !hasMatched &&
+                    (await this.filter(item, index, this.collection))
+                ) {
+                    yield* this.iterable;
+                    hasMatched = true;
+                }
+                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-insert-before-iterable.ts

@@ -0,0 +1,57 @@
+import {
+    type AsyncFilter,
+    type AsyncIterableValue,
+    CollectionError,
+    type IAsyncCollection,
+    IndexOverflowError,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncInsertBeforeIterable<TInput, TExtended>
+    implements AsyncIterable<TInput | TExtended>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private filter: AsyncFilter<TInput, IAsyncCollection<TInput>>,
+        private iterable: AsyncIterableValue<TInput | TExtended>,
+        private throwOnNumberLimit: boolean,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput | TExtended> {
+        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 &&
+                    (await this.filter(item, index, this.collection))
+                ) {
+                    yield* this.iterable;
+                    hasMatched = true;
+                }
+                yield item;
+                index++;
+            }
+        } catch (error: unknown) {
+            if (
+                error instanceof CollectionError ||
+                error instanceof TypeError
+            ) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(
+                `Unexpected error "${String(error)}" occured`,
+                error,
+            );
+        }
+    }
+}