@daiso-tech/core 0.1.0 → 0.1.2

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

@@ -1,32 +0,0 @@
-export * from "@/collection/iterable-collection/iterable-helpers/chunk-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/chunk-whilte-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/collapse-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/count-by-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/cross-join-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/entries-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/filter-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/flat-map-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/group-by-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/insert-after-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/insert-before-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/map-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/merge-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/pad-end-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/pad-start-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/partion-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/repeat-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/reverse-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/shuffle-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/skip-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/skip-until-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/slice-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/sliding-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/sort-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/split-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/take-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/take-until-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/tap-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/unique-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/update-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/when-iterable";
-export * from "@/collection/iterable-collection/iterable-helpers/zip-iterable";

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

@@ -1,49 +0,0 @@
-import {
-    CollectionError,
-    type ICollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class ChunkIterable<TInput> implements Iterable<ICollection<TInput>> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private chunkSize: number,
-        private readonly makeCollection: <TInput>(
-            iterable: Iterable<TInput>,
-        ) => ICollection<TInput>,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<ICollection<TInput>> {
-        try {
-            let chunk: ICollection<TInput> = this.makeCollection<TInput>([]),
-                currentChunkSize = 0,
-                isFirstIteration = true;
-            for (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/iterable-collection/iterable-helpers/chunk-whilte-iterable.ts

@@ -1,51 +0,0 @@
-import {
-    CollectionError,
-    type Filter,
-    type ICollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class ChunkWhileIterable<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 collection: ICollection<TInput> = this.makeCollection<TInput>(
-                [],
-            );
-            for (const [index, item] of this.collection.entries(
-                this.throwOnNumberLimit,
-            )) {
-                if (index === 0) {
-                    collection = collection.append([item]);
-                } else if (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/iterable-collection/iterable-helpers/collapse-iterable.ts

@@ -1,35 +0,0 @@
-import { isIterable } from "@/collection/_shared";
-import {
-    type Collapse,
-    CollectionError,
-    type ICollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class CollapseIterable<TInput> implements Iterable<Collapse<TInput>> {
-    constructor(private collection: ICollection<TInput>) {}
-
-    *[Symbol.iterator](): Iterator<Collapse<TInput>> {
-        try {
-            for (const item of this.collection) {
-                if (isIterable<TInput>(item)) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    yield* item as any;
-                } else {
-                    yield item as Collapse<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/iterable-collection/iterable-helpers/count-by-iterable.ts

@@ -1,49 +0,0 @@
-import {
-    CollectionError,
-    type ICollection,
-    type Map,
-    type RecordItem,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class CountByIterable<TInput, TOutput = TInput>
-    implements Iterable<RecordItem<TOutput, number>>
-{
-    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<RecordItem<TOutput, number>> {
-        try {
-            const map = new Map<TOutput, number>();
-            for (const [index, item] of this.collection.entries(
-                this.throwOnNumberLimit,
-            )) {
-                const key = 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/iterable-collection/iterable-helpers/cross-join-iterable.ts

@@ -1,57 +0,0 @@
-import {
-    CollectionError,
-    type ICollection,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class CrossJoinIterable<TInput, TExtended = TInput>
-    implements Iterable<ICollection<TInput | TExtended>>
-{
-    constructor(
-        private collection: ICollection<TInput>,
-        private iterables: Array<Iterable<TExtended>>,
-        private makeCollection: <TInput>(
-            iterable: Iterable<TInput>,
-        ) => ICollection<TInput>,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<ICollection<TInput | TExtended>> {
-        try {
-            yield* this.makeCollection<ICollection<TInput | TExtended>>([
-                this.collection,
-                ...this.iterables.map<ICollection<TExtended>>((iterable) =>
-                    this.makeCollection(iterable),
-                ),
-            ]).reduce<ICollection<ICollection<TInput | TExtended>>>({
-                reduceFn: (a, b) => {
-                    return a
-                        .map((x) =>
-                            b.map((y) => {
-                                return x.append([y]);
-                            }),
-                        )
-                        .reduce<ICollection<ICollection<TInput | TExtended>>>({
-                            reduceFn: (c, b) => c.append(b),
-                            initialValue: this.makeCollection<
-                                ICollection<TInput | TExtended>
-                            >([]),
-                        });
-                },
-                initialValue: this.makeCollection<
-                    ICollection<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/iterable-collection/iterable-helpers/entries-iterable.ts

@@ -1,42 +0,0 @@
-import {
-    type RecordItem,
-    CollectionError,
-    IndexOverflowError,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_shared";
-
-export class EntriesIterable<TInput>
-    implements Iterable<RecordItem<number, TInput>>
-{
-    constructor(
-        private iterable: Iterable<TInput>,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<RecordItem<number, TInput>> {
-        try {
-            let index = 0;
-            for (const item of this.iterable) {
-                if (
-                    this.throwOnNumberLimit &&
-                    index === Number.MAX_SAFE_INTEGER
-                ) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
-                yield [index, 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/iterable-collection/iterable-helpers/filter-iterable.ts

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

@@ -1,35 +0,0 @@
-import {
-    CollectionError,
-    type ICollection,
-    type Map,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class FlatMapIterable<TInput, TOutput> implements Iterable<TOutput> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private map: Map<TInput, ICollection<TInput>, Iterable<TOutput>>,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TOutput> {
-        try {
-            for (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/iterable-collection/iterable-helpers/group-by-iterable.ts

@@ -1,52 +0,0 @@
-import {
-    CollectionError,
-    UnexpectedCollectionError,
-    type ICollection,
-    type Map,
-    type RecordItem,
-} from "@/contracts/collection/_module";
-
-export class GroupByIterable<TInput, TOutput = TInput>
-    implements Iterable<RecordItem<TOutput, ICollection<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,
-        private makeCollection: <TInput>(
-            iterable: Iterable<TInput>,
-        ) => ICollection<TInput>,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<RecordItem<TOutput, ICollection<TInput>>> {
-        try {
-            const map = new Map<TOutput, ICollection<TInput>>();
-            for (const [index, item] of this.collection.entries(
-                this.throwOnNumberLimit,
-            )) {
-                const key = this.callback(item, index, this.collection);
-                let collection: ICollection<TInput> | undefined = map.get(key);
-                if (collection === undefined) {
-                    collection = this.makeCollection<TInput>([]);
-                    map.set(key, collection);
-                }
-
-                map.set(key, collection.append([item]));
-            }
-            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/iterable-collection/iterable-helpers/insert-after-iterable.ts

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

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

@@ -1,35 +0,0 @@
-import {
-    CollectionError,
-    type ICollection,
-    type Map,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class MapIterable<TInput, TOutput> implements Iterable<TOutput> {
-    constructor(
-        private collection: ICollection<TInput>,
-        private map: Map<TInput, ICollection<TInput>, TOutput>,
-        private throwOnNumberLimit: boolean,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<TOutput> {
-        try {
-            for (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/iterable-collection/iterable-helpers/merge-iterable.ts

@@ -1,31 +0,0 @@
-import {
-    CollectionError,
-    UnexpectedCollectionError,
-} from "@/contracts/collection/_module";
-
-export class MergeIterable<TInput, TExtended>
-    implements Iterable<TInput | TExtended>
-{
-    constructor(
-        private iterableA: Iterable<TInput>,
-        private iterableB: Iterable<TExtended>,
-    ) {}
-
-    *[Symbol.iterator](): Iterator<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/iterable-collection/iterable-helpers/pad-end-iterable.ts

@@ -1,52 +0,0 @@
-import {
-    CollectionError,
-    UnexpectedCollectionError,
-    type ICollection,
-} from "@/contracts/collection/_module";
-
-export class PadEndIterable<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.prepend(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,
-            );
-        }
-    }
-}