@daiso-tech/core 0.1.1 → 0.1.2

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

@@ -1,34 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

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