@daiso-tech/core 0.1.1 → 0.1.3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,57 +0,0 @@
-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,
-            );
-        }
-    }
-}