@daiso-tech/core 0.1.0 → 0.1.2

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

@@ -1,40 +0,0 @@
-import {
-    type AsyncMap,
-    CollectionError,
-    type IAsyncCollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-/**
- * @internal
- */
-export class AsyncMapIterable<TInput, TOutput>
-    implements AsyncIterable<TOutput>
-{
-    constructor(
-        private collection: IAsyncCollection<TInput>,
-        private map: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    async *[Symbol.asyncIterator](): AsyncIterator<TOutput> {
-        try {
-            for await (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/async-iterable-collection/async-iterable-helpers/async-merge-iterable.ts

@@ -1,35 +0,0 @@
-import {
-    type AsyncIterableValue,
-    CollectionError,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-/**
- * @internal
- */
-export class AsyncMergeIterable<TInput, TExtended>
-    implements AsyncIterable<TInput | TExtended>
-{
-    constructor(
-        private iterableA: AsyncIterableValue<TInput>,
-        private iterableB: AsyncIterableValue<TExtended>,
-    ) {}
-
-    async *[Symbol.asyncIterator](): AsyncIterator<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/async-iterable-collection/async-iterable-helpers/async-pad-end-iterable.ts

@@ -1,41 +0,0 @@
-import {
-    AsyncIterableValue,
-    type IAsyncCollection,
-} from "@/contracts/collection/_module";
-
-/**
- * @internal
- */
-export class AsyncPadEndIterable<TInput, TExtended>
-    implements AsyncIterable<TInput | TExtended>
-{
-    constructor(
-        private collection: IAsyncCollection<TInput>,
-        private maxLength: number,
-        private fillItems: AsyncIterableValue<TExtended>,
-        private makeCollection: <TInput>(
-            iterable: AsyncIterableValue<TInput>,
-        ) => IAsyncCollection<TInput>,
-    ) {}
-
-    async *[Symbol.asyncIterator](): AsyncIterator<TInput | TExtended> {
-        const fillCollections = this.makeCollection(this.fillItems);
-        const fillSize = await fillCollections.size();
-        const size = await this.collection.size();
-        const repeat = Math.floor((this.maxLength - size) / fillSize);
-        let resultCollection: IAsyncCollection<TInput | TExtended> =
-            this.makeCollection<TInput | TExtended>([]);
-        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;
-    }
-}

package/src/collection/async-iterable-collection/async-iterable-helpers/async-pad-start-iterable.ts

@@ -1,41 +0,0 @@
-import {
-    AsyncIterableValue,
-    type IAsyncCollection,
-} from "@/contracts/collection/_module";
-
-/**
- * @internal
- */
-export class AsyncPadStartIterable<TInput, TExtended>
-    implements AsyncIterable<TInput | TExtended>
-{
-    constructor(
-        private collection: IAsyncCollection<TInput>,
-        private maxLength: number,
-        private fillItems: AsyncIterableValue<TExtended>,
-        private makeCollection: <TInput>(
-            iterable: AsyncIterableValue<TInput>,
-        ) => IAsyncCollection<TInput>,
-    ) {}
-
-    async *[Symbol.asyncIterator](): AsyncIterator<TInput | TExtended> {
-        const fillCollections = this.makeCollection(this.fillItems);
-        const fillSize = await fillCollections.size();
-        const size = await this.collection.size();
-        const repeat = Math.floor((this.maxLength - size) / fillSize);
-        let resultCollection: IAsyncCollection<TInput | TExtended> =
-            this.makeCollection<TInput | TExtended>([]);
-        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.append(this.collection);
-        yield* resultCollection;
-    }
-}

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

@@ -1,63 +0,0 @@
-import {
-    type AsyncFilter,
-    type AsyncIterableValue,
-    CollectionError,
-    type IAsyncCollection,
-    IndexOverflowError,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-/**
- * @internal
- */
-export class AsyncPartionIterable<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 chunkA: IAsyncCollection<TInput> = this.makeCollection<TInput>(
-                    [],
-                ),
-                chunkB: IAsyncCollection<TInput> = this.makeCollection<TInput>(
-                    [],
-                ),
-                index = 0;
-            for await (const item of this.collection) {
-                if (
-                    this.throwOnNumberLimit &&
-                    index === Number.MAX_SAFE_INTEGER
-                ) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
-                if (await this.filter(item, index, this.collection)) {
-                    chunkA = chunkA.append([item]);
-                } else {
-                    chunkB = chunkB.append([item]);
-                }
-                index++;
-            }
-            yield chunkA;
-            yield chunkB;
-        } 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-repeat-iterable.ts

@@ -1,40 +0,0 @@
-import {
-    type AsyncIterableValue,
-    CollectionError,
-    type IAsyncCollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-/**
- * @internal
- */
-export class AsyncRepeatIterable<TInput> implements AsyncIterable<TInput> {
-    constructor(
-        private collection: IAsyncCollection<TInput>,
-        private amount: number,
-        private makeAsyncCollection: <TInput>(
-            iterable: AsyncIterableValue<TInput>,
-        ) => IAsyncCollection<TInput>,
-    ) {}
-
-    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
-        try {
-            let collection = this.makeAsyncCollection<TInput>([]);
-            for (let index = 0; index < this.amount - 1; index++) {
-                collection = collection.append(this.collection);
-            }
-            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-reverse-iterable.ts

@@ -1,35 +0,0 @@
-import {
-    type AsyncIterableValue,
-    type IAsyncCollection,
-} from "@/contracts/collection/_module";
-
-/**
- * @internal
- */
-export class AsyncReverseIterable<TInput> implements AsyncIterable<TInput> {
-    constructor(
-        private collection: IAsyncCollection<TInput>,
-        private chunkSize: number,
-        private throwOnNumberLimit: boolean,
-        private makeCollection: <TInput>(
-            iterable: AsyncIterableValue<TInput>,
-        ) => IAsyncCollection<TInput>,
-    ) {}
-
-    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
-        const collection: IAsyncCollection<TInput> =
-            this.makeCollection<TInput>([]);
-        yield* await this.collection
-            .chunk(this.chunkSize)
-            .map(
-                async (item) =>
-                    this.makeCollection([...(await item.toArray())].reverse()),
-                this.throwOnNumberLimit,
-            )
-            .reduce({
-                reduceFn: (collection, item) => collection.prepend(item),
-                initialValue: collection,
-                throwOnNumberLimit: this.throwOnNumberLimit,
-            });
-    }
-}

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

@@ -1,41 +0,0 @@
-import {
-    CollectionError,
-    type IAsyncCollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-/**
- * @internal
- */
-export class AsyncSkipIterable<TInput> implements AsyncIterable<TInput> {
-    constructor(
-        private collection: IAsyncCollection<TInput>,
-        private limit: number,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
-        try {
-            if (this.limit < 0) {
-                this.limit =
-                    (await this.collection.size(this.throwOnNumberLimit)) +
-                    this.limit;
-            }
-            yield* this.collection.skipWhile(
-                (_item, index) => index < this.limit,
-                this.throwOnNumberLimit,
-            );
-        } 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-skip-until-iterable.ts

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

@@ -1,54 +0,0 @@
-import {
-    CollectionError,
-    type IAsyncCollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-/**
- * @internal
- */
-export class AsyncSlidingIteralbe<TInput>
-    implements AsyncIterable<IAsyncCollection<TInput>>
-{
-    constructor(
-        private collection: IAsyncCollection<TInput>,
-        private chunkSize: number,
-        private step: number,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    async *[Symbol.asyncIterator](): AsyncIterator<IAsyncCollection<TInput>> {
-        try {
-            if (this.step <= 0) {
-                return;
-            }
-            const size = await this.collection.size(this.throwOnNumberLimit);
-
-            for (let index = 0; index < size; index += this.step) {
-                const start = index;
-                const end = index + this.chunkSize;
-
-                yield this.collection.slice({
-                    start,
-                    end,
-                    throwOnNumberLimit: this.throwOnNumberLimit,
-                });
-
-                if (end >= size) {
-                    break;
-                }
-            }
-        } 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-sort-iterable.ts

@@ -1,18 +0,0 @@
-import {
-    type Comparator,
-    type IAsyncCollection,
-} from "@/contracts/collection/_module";
-
-/**
- * @internal
- */
-export class AsyncSortIterable<TInput> implements AsyncIterable<TInput> {
-    constructor(
-        private collection: IAsyncCollection<TInput>,
-        private compare?: Comparator<TInput>,
-    ) {}
-
-    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
-        yield* [...(await this.collection.toArray())].sort(this.compare);
-    }
-}

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

@@ -1,64 +0,0 @@
-import {
-    type AsyncIterableValue,
-    CollectionError,
-    type IAsyncCollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-/**
- * @internal
- */
-export class AsyncSplitIterable<TInput>
-    implements AsyncIterable<IAsyncCollection<TInput>>
-{
-    constructor(
-        private collection: IAsyncCollection<TInput>,
-        private chunkAmount: number,
-        private throwOnNumberLimit: boolean,
-        private makeCollection: <TInput>(
-            iterable: AsyncIterableValue<TInput>,
-        ) => IAsyncCollection<TInput>,
-    ) {}
-
-    async *[Symbol.asyncIterator](): AsyncIterator<IAsyncCollection<TInput>> {
-        try {
-            const size = await this.collection.size(this.throwOnNumberLimit),
-                minChunkSize = Math.floor(size / this.chunkAmount),
-                restSize = size % this.chunkAmount,
-                chunkSizes = Array.from<number>({
-                    length: this.chunkAmount,
-                }).fill(minChunkSize);
-
-            for (let i = 1; i <= restSize; i++) {
-                const chunkIndex = (i - 1) % this.chunkAmount;
-                if (chunkSizes[chunkIndex]) {
-                    chunkSizes[chunkIndex] = chunkSizes[chunkIndex] + 1;
-                }
-            }
-
-            const iterator = this.collection.iterator();
-            for (const chunkSize of chunkSizes) {
-                let collection: IAsyncCollection<TInput> =
-                    this.makeCollection<TInput>([]);
-                for (let i = 0; i < chunkSize; i++) {
-                    const item = await iterator.next();
-                    if (item.value !== undefined) {
-                        collection = collection.append([item.value]);
-                    }
-                }
-                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-take-iterable.ts

@@ -1,41 +0,0 @@
-import {
-    CollectionError,
-    type IAsyncCollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-/**
- * @internal
- */
-export class AsyncTakeIterable<TInput> implements AsyncIterable<TInput> {
-    constructor(
-        private collection: IAsyncCollection<TInput>,
-        private limit: number,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    async *[Symbol.asyncIterator](): AsyncIterator<TInput> {
-        try {
-            if (this.limit < 0) {
-                this.limit =
-                    (await this.collection.size(this.throwOnNumberLimit)) +
-                    this.limit;
-            }
-            yield* this.collection.takeWhile(
-                (_item, index) => index < this.limit,
-                this.throwOnNumberLimit,
-            );
-        } 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-take-until-iterable.ts

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