@daiso-tech/core 0.1.0 → 0.1.2

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

@@ -1,52 +0,0 @@
-import {
-    CollectionError,
-    UnexpectedCollectionError,
-    type ICollection,
-} from "@/contracts/collection/_module";
-
-export class PadStartIterable<TInput, TExtended>
-    implements Iterable<TInput | TExtended>
-{
-    constructor(
-        private collection: ICollection<TInput>,
-        private maxLength: number,
-        private fillItems: Iterable<TExtended>,
-        private makeCollection: <TInput>(
-            iterable: Iterable<TInput | TExtended>,
-        ) => ICollection<TInput | TExtended>,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TInput | TExtended> {
-        try {
-            const fillCollections = this.makeCollection<TInput>(this.fillItems);
-            const fillSize = fillCollections.size();
-            const size = this.collection.size();
-            const repeat = Math.floor((this.maxLength - size) / fillSize);
-            let resultCollection: ICollection<TInput | TExtended> =
-                this.makeCollection<TInput>([]);
-            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;
-        } catch (error: unknown) {
-            if (
-                error instanceof CollectionError ||
-                error instanceof TypeError
-            ) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(
-                `Unexpected error "${String(error)}" occured`,
-                error,
-            );
-        }
-    }
-}

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

@@ -1,46 +0,0 @@
-import {
-    CollectionError,
-    type Filter,
-    type ICollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class PartionIterable<TInput> implements Iterable<ICollection<TInput>> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private filter: Filter<TInput, ICollection<TInput>>,
-        private throwOnNumberLimit: boolean,
-        private makeCollection: <TInput>(
-            iterable: Iterable<TInput>,
-        ) => ICollection<TInput>,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<ICollection<TInput>> {
-        try {
-            let chunkA: ICollection<TInput> = this.makeCollection<TInput>([]),
-                chunkB: ICollection<TInput> = this.makeCollection<TInput>([]);
-            for (const [index, item] of this.collection.entries(
-                this.throwOnNumberLimit,
-            )) {
-                if (this.filter(item, index, this.collection)) {
-                    chunkA = chunkA.append([item]);
-                } else {
-                    chunkB = chunkB.append([item]);
-                }
-            }
-            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/iterable-collection/iterable-helpers/repeat-iterable.ts

@@ -1,36 +0,0 @@
-import {
-    CollectionError,
-    UnexpectedCollectionError,
-    type ICollection,
-} from "@/contracts/collection/_module";
-
-export class RepeatIterable<TInput> implements Iterable<TInput> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private amount: number,
-        private makeCollection: <TInput>(
-            iterable: Iterable<TInput>,
-        ) => ICollection<TInput>,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TInput> {
-        try {
-            let collection = this.makeCollection<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/iterable-collection/iterable-helpers/reverse-iterable.ts

@@ -1,46 +0,0 @@
-import {
-    CollectionError,
-    UnexpectedCollectionError,
-    type ICollection,
-} from "@/contracts/collection/_module";
-
-export class ReverseIterable<TInput> implements Iterable<TInput> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private chunkSize: number,
-        private throwOnNumberLimit: boolean,
-        private makeCollection: <TInput>(
-            iterable: Iterable<TInput>,
-        ) => ICollection<TInput>,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TInput> {
-        try {
-            const collection: ICollection<TInput> = this.makeCollection<TInput>(
-                [],
-            );
-            yield* this.collection
-                .chunk(this.chunkSize)
-                .map(
-                    (item) => this.makeCollection<TInput>([...item].reverse()),
-                    this.throwOnNumberLimit,
-                )
-                .reduce({
-                    reduceFn: (collection, item) => collection.prepend(item),
-                    initialValue: collection,
-                    throwOnNumberLimit: 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/iterable-collection/iterable-helpers/shuffle-iterable.ts

@@ -1,36 +0,0 @@
-import {
-    CollectionError,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_shared";
-
-export class ShuffleIterable<TInput> implements Iterable<TInput> {
-    constructor(private iterable: Iterable<TInput>) {}
-
-    *[Symbol.iterator](): Iterator<TInput> {
-        try {
-            const newArray = [...this.iterable];
-            for (let i = newArray.length - 1; i > 0; i--) {
-                const j = Math.floor(Math.random() * (i + 1));
-                const temp = newArray[i];
-                if (newArray[j] !== undefined) {
-                    newArray[i] = newArray[j];
-                }
-                if (temp !== undefined) {
-                    newArray[j] = temp;
-                }
-            }
-            yield* newArray;
-        } catch (error: unknown) {
-            if (
-                error instanceof CollectionError ||
-                error instanceof TypeError
-            ) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(
-                `Unexpected error "${String(error)}" occured`,
-                error,
-            );
-        }
-    }
-}

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

@@ -1,37 +0,0 @@
-import {
-    CollectionError,
-    type ICollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class SkipIterable<TInput> implements Iterable<TInput> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private offset: number,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TInput> {
-        try {
-            if (this.offset < 0) {
-                this.offset =
-                    this.collection.size(this.throwOnNumberLimit) + this.offset;
-            }
-            yield* this.collection.skipWhile(
-                (_item, index) => index < this.offset,
-                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/iterable-collection/iterable-helpers/skip-until-iterable.ts

@@ -1,41 +0,0 @@
-import {
-    CollectionError,
-    type Filter,
-    type ICollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class SkipUntilIterable<TInput> implements Iterable<TInput> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private filter: Filter<TInput, ICollection<TInput>>,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TInput> {
-        try {
-            let hasMatched = false;
-            for (const [index, item] of this.collection.entries(
-                this.throwOnNumberLimit,
-            )) {
-                if (!hasMatched) {
-                    hasMatched = this.filter(item, index, this.collection);
-                }
-                if (hasMatched) {
-                    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/iterable-collection/iterable-helpers/slice-iterable.ts

@@ -1,47 +0,0 @@
-import {
-    CollectionError,
-    UnexpectedCollectionError,
-    type ICollection,
-} from "@/contracts/collection/_module";
-
-export class SliceIterable<TInput> implements Iterable<TInput> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private start: number | undefined,
-        private end: number | undefined,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TInput> {
-        try {
-            const size = this.collection.size();
-            let { start, end } = this;
-            if (start === undefined) {
-                start = 0;
-            }
-            if (end === undefined) {
-                end = size;
-            }
-            if (start < 0) {
-                start = size + start;
-            }
-            if (end < 0) {
-                end = size + end;
-            }
-            yield* this.collection.filter((_item, index) => {
-                return start <= index && index < end;
-            }, 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/iterable-collection/iterable-helpers/sliding-iterable.ts

@@ -1,49 +0,0 @@
-import {
-    CollectionError,
-    type ICollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class SlidingIteralbe<TInput> implements Iterable<ICollection<TInput>> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private chunkSize: number,
-        private step: number,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<ICollection<TInput>> {
-        try {
-            if (this.step <= 0) {
-                return;
-            }
-            const size = 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/iterable-collection/iterable-helpers/sort-iterable.ts

@@ -1,29 +0,0 @@
-import {
-    CollectionError,
-    UnexpectedCollectionError,
-    type Comparator,
-} from "@/contracts/collection/_module";
-
-export class SortIterable<TInput> implements Iterable<TInput> {
-    constructor(
-        private iterable: Iterable<TInput>,
-        private compare?: Comparator<TInput>,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TInput> {
-        try {
-            yield* [...this.iterable].sort(this.compare);
-        } catch (error: unknown) {
-            if (
-                error instanceof CollectionError ||
-                error instanceof TypeError
-            ) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(
-                `Unexpected error "${String(error)}" occured`,
-                error,
-            );
-        }
-    }
-}

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

@@ -1,58 +0,0 @@
-import {
-    CollectionError,
-    type ICollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class SplitIterable<TInput> implements Iterable<ICollection<TInput>> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private chunkAmount: number,
-        private throwOnNumberLimit: boolean,
-        private makeCollection: <TInput>(
-            iterable: Iterable<TInput>,
-        ) => ICollection<TInput>,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<ICollection<TInput>> {
-        try {
-            const size = 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: ICollection<TInput> =
-                    this.makeCollection<TInput>([]);
-                for (let i = 0; i < chunkSize; i++) {
-                    const item = 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/iterable-collection/iterable-helpers/take-iterable.ts

@@ -1,37 +0,0 @@
-import {
-    CollectionError,
-    type ICollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class TakeIterable<TInput> implements Iterable<TInput> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private limit: number,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TInput> {
-        try {
-            if (this.limit < 0) {
-                this.limit =
-                    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/iterable-collection/iterable-helpers/take-until-iterable.ts

@@ -1,38 +0,0 @@
-import {
-    CollectionError,
-    type Filter,
-    type ICollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class TakeUntilIterable<TInput> implements Iterable<TInput> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private filter: Filter<TInput, ICollection<TInput>>,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TInput> {
-        try {
-            for (const [index, item] of this.collection.entries(
-                this.throwOnNumberLimit,
-            )) {
-                if (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/iterable-collection/iterable-helpers/tap-iterable.ts

@@ -1,31 +0,0 @@
-import {
-    CollectionError,
-    type ICollection,
-    type Tap,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class TapIterable<TInput> implements Iterable<TInput> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private callback: Tap<ICollection<TInput>>,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TInput> {
-        try {
-            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/iterable-collection/iterable-helpers/unique-iterable.ts

@@ -1,43 +0,0 @@
-import {
-    CollectionError,
-    type ICollection,
-    type Map,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class UniqueIterable<TInput, TOutput> implements Iterable<TInput> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private callback: Map<TInput, ICollection<TInput>, TOutput> = (item) =>
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
-            item as any,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TInput> {
-        try {
-            const set = new Set<TOutput>([]);
-
-            for (const [index, item] of this.collection.entries(
-                this.throwOnNumberLimit,
-            )) {
-                const item_ = 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/iterable-collection/iterable-helpers/update-iterable.ts

@@ -1,50 +0,0 @@
-import {
-    CollectionError,
-    type Filter,
-    type ICollection,
-    type Map,
-    UnexpectedCollectionError,
-    type UpdatedItem,
-} from "@/contracts/collection/_module";
-
-export class UpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput>
-    implements Iterable<UpdatedItem<TInput, TFilterOutput, TMapOutput>>
-{
-    constructor(
-        private collection: ICollection<TInput>,
-        private filter: Filter<TInput, ICollection<TInput>, TFilterOutput>,
-        private map: Map<TFilterOutput, ICollection<TInput>, TMapOutput>,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<
-        UpdatedItem<TInput, TFilterOutput, TMapOutput>
-    > {
-        try {
-            for (const [index, item] of this.collection.entries(
-                this.throwOnNumberLimit,
-            )) {
-                if (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,
-            );
-        }
-    }
-}