@daiso-tech/core 0.0.1

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

@@ -0,0 +1,34 @@
+import {
+    type AsyncTap,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncTapIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private callback: AsyncTap<IAsyncCollection<TInput>>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        try {
+            await 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/async-iterable-collection/async-iterable-helpers/async-timeout-iterable.ts

@@ -0,0 +1,20 @@
+import { type IAsyncCollection } from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncTimeoutIterable<TInput> implements AsyncIterable<TInput> {
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private timeInMs: number,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        const abortController = new AbortController();
+        const timeout = setTimeout(() => {
+            abortController.abort();
+        }, this.timeInMs);
+        yield* this.collection.abort(abortController.signal);
+        clearTimeout(timeout);
+    }
+}

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

@@ -0,0 +1,49 @@
+import {
+    type AsyncMap,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncUniqueIterable<TInput, TOutput>
+    implements AsyncIterable<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,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
+        try {
+            const set = new Set<TOutput>([]);
+            for await (const [index, item] of this.collection.entries()) {
+                const item_ = await 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/async-iterable-collection/async-iterable-helpers/async-update-iterable.ts

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

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

@@ -0,0 +1,43 @@
+import {
+    type AsyncModifier,
+    CollectionError,
+    type IAsyncCollection,
+    UnexpectedCollectionError,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncWhenIterable<TInput, TExtended>
+    implements AsyncIterable<TInput | TExtended>
+{
+    constructor(
+        private collection: IAsyncCollection<TInput>,
+        private condition: () => boolean | Promise<boolean>,
+        private callback: AsyncModifier<
+            IAsyncCollection<TInput>,
+            IAsyncCollection<TExtended>
+        >,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<TInput | TExtended> {
+        try {
+            if (await this.condition()) {
+                yield* await this.callback(this.collection);
+                return;
+            }
+            yield* this.collection as IAsyncCollection<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-zip-iterable.ts

@@ -0,0 +1,45 @@
+import { isIterable } from "@/collection/_shared";
+import {
+    type AsyncIterableValue,
+    type RecordItem,
+} from "@/contracts/collection/_module";
+
+/**
+ * @internal
+ */
+export class AsyncZipIterable<TInput, TExtended>
+    implements AsyncIterable<RecordItem<TInput, TExtended>>
+{
+    constructor(
+        private iterableA: AsyncIterableValue<TInput>,
+        private iterableB: AsyncIterableValue<TExtended>,
+    ) {}
+
+    async *[Symbol.asyncIterator](): AsyncIterator<
+        RecordItem<TInput, TExtended>
+    > {
+        let iteratorA: AsyncIterator<TInput> | Iterator<TInput>;
+        if (isIterable(this.iterableA)) {
+            iteratorA = this.iterableA[Symbol.iterator]();
+        } else {
+            iteratorA = this.iterableA[Symbol.asyncIterator]();
+        }
+
+        let iteratorB: AsyncIterator<TExtended> | Iterator<TExtended>;
+        if (isIterable(this.iterableB)) {
+            iteratorB = this.iterableB[Symbol.iterator]();
+        } else {
+            iteratorB = this.iterableB[Symbol.asyncIterator]();
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        while (true) {
+            const itemA = await iteratorA.next(),
+                itemB = await iteratorB.next();
+            if (itemA.done || itemB.done) {
+                break;
+            }
+            yield [itemA.value, itemB.value];
+        }
+    }
+}

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

@@ -0,0 +1 @@
+export * from "@/collection/iterable-collection/iterable-collection";