@daiso-tech/core 0.1.2 → 0.1.4

package/dist/types/collection/async-iterable-collection/async-iterable-collection.d.ts

@@ -1,42 +1,50 @@
-import { type AsyncCollapse, type AsyncFilter, type AsyncFindOrSettings, type AsyncFindSettings, type AsyncForEach, type AsyncGroupBySettings, type AsyncIterableValue, type AsyncLazyable, type AsyncMap, type AsyncModifier, type AsyncReduceSettings, type AsyncTap, type AsyncTransform, type Comparator, type IAsyncCollection, type JoinSettings, type PageSettings, type RecordItem, type ReverseSettings, type SliceSettings, type SlidingSettings, type UpdatedItem } from "../../contracts/collection/_module";
-import { EnsureType } from "../../types";
 /**
- * Most methods in AsyncIterableCollection are lazy and will only execute when calling methods return values or iterating through an IterableCollection by using for of loop
- * @group Collections
+ * @module Collections
+ */
+import { type AsyncCollapse, type AsyncPredicate, type AsyncFindOrSettings, type AsyncFindSettings, type AsyncForEach, type AsyncGroupBySettings, type AsyncCountBySettings, type AsyncUniqueSettings, type AsyncIterableValue, type AsyncLazyable, type AsyncMap, type AsyncModifier, type AsyncReduceSettings, type AsyncTap, type AsyncTransform, type Comparator, type IAsyncCollection, type JoinSettings, type PageSettings, type RecordItem, type ReverseSettings, type SliceSettings, type SlidingSettings, type UpdatedItem } from "../../contracts/collection/_module";
+import { EnsureType } from "../../_shared/types";
+/**
+ * All methods that return <i>{@link IAsyncCollection}</i> are executed lazly which means they will be executed when the <i>AsyncIterableCollection</i> is iterated with <i>forEach</i> method or "for await of" loop.
+ * The rest of the methods are executed eagerly.
+ * @group Adapters
  */
 export declare class AsyncIterableCollection<TInput> implements IAsyncCollection<TInput> {
     private iterable;
     private static THROW_ON_NUMBER_LIMIT;
     private static DEFAULT_CHUNK_SIZE;
     private static makeCollection;
+    /**
+     * The <i>constructor</i> takes an <i>{@link Iterable}</i> or <i>{@link AsyncIterable}</i>.
+     */
     constructor(iterable?: AsyncIterableValue<TInput>);
     [Symbol.asyncIterator](): AsyncIterator<TInput>;
-    iterator(): AsyncIterator<TInput, void>;
-    entries(throwOnNumberLimit?: boolean): IAsyncCollection<RecordItem<number, TInput>>;
-    keys(throwOnNumberLimit?: boolean): IAsyncCollection<number>;
+    toIterator(): AsyncIterator<TInput, void>;
+    entries(throwOnIndexOverflow?: boolean): IAsyncCollection<RecordItem<number, TInput>>;
+    keys(throwOnIndexOverflow?: boolean): IAsyncCollection<number>;
     values(): IAsyncCollection<TInput>;
-    filter<TOutput extends TInput>(filter: AsyncFilter<TInput, IAsyncCollection<TInput>, TOutput>, throwOnNumberLimit?: boolean): IAsyncCollection<TOutput>;
-    map<TOutput>(map: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>, throwOnNumberLimit?: boolean): IAsyncCollection<TOutput>;
+    filter<TOutput extends TInput>(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>, throwOnIndexOverflow?: boolean): IAsyncCollection<TOutput>;
+    reject<TOutput extends TInput>(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>, throwOnIndexOverflow?: boolean): IAsyncCollection<Exclude<TInput, TOutput>>;
+    map<TOutput>(mapFn: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>, throwOnIndexOverflow?: boolean): IAsyncCollection<TOutput>;
     reduce<TOutput = TInput>(settings: AsyncReduceSettings<TInput, IAsyncCollection<TInput>, TOutput>): Promise<TOutput>;
-    join(settings?: JoinSettings): Promise<string>;
+    join(settings?: JoinSettings): Promise<EnsureType<TInput, string>>;
     collapse(): IAsyncCollection<AsyncCollapse<TInput>>;
-    flatMap<TOutput>(map: AsyncMap<TInput, IAsyncCollection<TInput>, Iterable<TOutput>>, throwOnNumberLimit?: boolean): IAsyncCollection<TOutput>;
-    update<TFilterOutput extends TInput, TMapOutput>(filter: AsyncFilter<TInput, IAsyncCollection<TInput>, TFilterOutput>, map: AsyncMap<TFilterOutput, IAsyncCollection<TInput>, TMapOutput>, throwOnNumberLimit?: boolean): IAsyncCollection<UpdatedItem<TInput, TFilterOutput, TMapOutput>>;
+    flatMap<TOutput>(mapFn: AsyncMap<TInput, IAsyncCollection<TInput>, Iterable<TOutput>>, throwOnIndexOverflow?: boolean): IAsyncCollection<TOutput>;
+    update<TFilterOutput extends TInput, TMapOutput>(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>, TFilterOutput>, mapFn: AsyncMap<TFilterOutput, IAsyncCollection<TInput>, TMapOutput>, throwOnIndexOverflow?: boolean): IAsyncCollection<UpdatedItem<TInput, TFilterOutput, TMapOutput>>;
     page(settings: PageSettings): IAsyncCollection<TInput>;
     sum(): Promise<EnsureType<TInput, number>>;
     average(): Promise<EnsureType<TInput, number>>;
-    median(throwOnNumberLimit?: boolean): Promise<EnsureType<TInput, number>>;
+    median(throwOnIndexOverflow?: boolean): Promise<EnsureType<TInput, number>>;
     min(): Promise<EnsureType<TInput, number>>;
     max(): Promise<EnsureType<TInput, number>>;
-    percentage(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): Promise<number>;
-    some<TOutput extends TInput>(filter: AsyncFilter<TInput, IAsyncCollection<TInput>, TOutput>, throwOnNumberLimit?: boolean): Promise<boolean>;
-    every<TOutput extends TInput>(filter: AsyncFilter<TInput, IAsyncCollection<TInput>, TOutput>, throwOnNumberLimit?: boolean): Promise<boolean>;
-    take(limit: number, throwOnNumberLimit?: boolean): IAsyncCollection<TInput>;
-    takeUntil(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): IAsyncCollection<TInput>;
-    takeWhile(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): IAsyncCollection<TInput>;
-    skip(offset: number, throwOnNumberLimit?: boolean): IAsyncCollection<TInput>;
-    skipUntil(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): IAsyncCollection<TInput>;
-    skipWhile(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): IAsyncCollection<TInput>;
+    percentage(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): Promise<number>;
+    some<TOutput extends TInput>(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>, throwOnIndexOverflow?: boolean): Promise<boolean>;
+    every<TOutput extends TInput>(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>, throwOnIndexOverflow?: boolean): Promise<boolean>;
+    take(limit: number, throwOnIndexOverflow?: boolean): IAsyncCollection<TInput>;
+    takeUntil(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): IAsyncCollection<TInput>;
+    takeWhile(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): IAsyncCollection<TInput>;
+    skip(offset: number, throwOnIndexOverflow?: boolean): IAsyncCollection<TInput>;
+    skipUntil(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): IAsyncCollection<TInput>;
+    skipWhile(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): IAsyncCollection<TInput>;
     when<TExtended = TInput>(condition: boolean, callback: AsyncModifier<IAsyncCollection<TInput>, IAsyncCollection<TExtended>>): IAsyncCollection<TInput | TExtended>;
     whenEmpty<TExtended = TInput>(callback: AsyncModifier<IAsyncCollection<TInput>, IAsyncCollection<TExtended>>): IAsyncCollection<TInput | TExtended>;
     whenNot<TExtended = TInput>(condition: boolean, callback: AsyncModifier<IAsyncCollection<TInput>, IAsyncCollection<TExtended>>): IAsyncCollection<TInput | TExtended>;
@@ -44,25 +52,25 @@ export declare class AsyncIterableCollection<TInput> implements IAsyncCollection
     pipe<TOutput = TInput>(callback: AsyncTransform<IAsyncCollection<TInput>, TOutput>): Promise<TOutput>;
     tap(callback: AsyncTap<IAsyncCollection<TInput>>): IAsyncCollection<TInput>;
     chunk(chunkSize: number): IAsyncCollection<IAsyncCollection<TInput>>;
-    chunkWhile(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): IAsyncCollection<IAsyncCollection<TInput>>;
-    split(chunkAmount: number, throwOnNumberLimit?: boolean): IAsyncCollection<IAsyncCollection<TInput>>;
-    partition(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): IAsyncCollection<IAsyncCollection<TInput>>;
+    chunkWhile(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): IAsyncCollection<IAsyncCollection<TInput>>;
+    split(chunkAmount: number, throwOnIndexOverflow?: boolean): IAsyncCollection<IAsyncCollection<TInput>>;
+    partition(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): IAsyncCollection<IAsyncCollection<TInput>>;
     sliding(settings: SlidingSettings): IAsyncCollection<IAsyncCollection<TInput>>;
     groupBy<TOutput = TInput>(settings?: AsyncGroupBySettings<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<RecordItem<TOutput, IAsyncCollection<TInput>>>;
-    countBy<TOutput = TInput>(settings?: AsyncGroupBySettings<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<RecordItem<TOutput, number>>;
-    unique<TOutput = TInput>(settings?: AsyncGroupBySettings<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<TInput>;
-    difference<TOutput = TInput>(iterable: AsyncIterableValue<TInput>, map?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<TInput>;
+    countBy<TOutput = TInput>(settings?: AsyncCountBySettings<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<RecordItem<TOutput, number>>;
+    unique<TOutput = TInput>(settings?: AsyncUniqueSettings<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<TInput>;
+    difference<TOutput = TInput>(iterable: AsyncIterableValue<TInput>, selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<TInput>;
     repeat(amount: number): IAsyncCollection<TInput>;
     padStart<TExtended = TInput>(maxLength: number, fillItems: AsyncIterableValue<TExtended>): IAsyncCollection<TInput | TExtended>;
     padEnd<TExtended = TInput>(maxLength: number, fillItems: AsyncIterableValue<TExtended>): IAsyncCollection<TInput | TExtended>;
     slice(settings?: SliceSettings): IAsyncCollection<TInput>;
     prepend<TExtended = TInput>(iterable: AsyncIterableValue<TInput | TExtended>): IAsyncCollection<TInput | TExtended>;
     append<TExtended = TInput>(iterable: AsyncIterableValue<TInput | TExtended>): IAsyncCollection<TInput | TExtended>;
-    insertBefore<TExtended = TInput>(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, iterable: AsyncIterableValue<TInput | TExtended>, throwOnNumberLimit?: boolean): IAsyncCollection<TInput | TExtended>;
-    insertAfter<TExtended = TInput>(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, iterable: AsyncIterableValue<TInput | TExtended>, throwOnNumberLimit?: boolean): IAsyncCollection<TInput | TExtended>;
+    insertBefore<TExtended = TInput>(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, iterable: AsyncIterableValue<TInput | TExtended>, throwOnIndexOverflow?: boolean): IAsyncCollection<TInput | TExtended>;
+    insertAfter<TExtended = TInput>(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, iterable: AsyncIterableValue<TInput | TExtended>, throwOnIndexOverflow?: boolean): IAsyncCollection<TInput | TExtended>;
     crossJoin<TExtended = TInput>(...iterables: Array<AsyncIterableValue<TExtended>>): IAsyncCollection<IAsyncCollection<TInput | TExtended>>;
     zip<TExtended>(iterable: AsyncIterableValue<TExtended>): IAsyncCollection<RecordItem<TInput, TExtended>>;
-    sort(compare?: Comparator<TInput> | undefined): IAsyncCollection<TInput>;
+    sort(comparator?: Comparator<TInput> | undefined): IAsyncCollection<TInput>;
     reverse(settings?: ReverseSettings): IAsyncCollection<TInput>;
     shuffle(): IAsyncCollection<TInput>;
     first<TOutput extends TInput>(settings?: AsyncFindSettings<TInput, IAsyncCollection<TInput>, TOutput>): Promise<TOutput | null>;
@@ -71,22 +79,23 @@ export declare class AsyncIterableCollection<TInput> implements IAsyncCollection
     last<TOutput extends TInput>(settings?: AsyncFindSettings<TInput, IAsyncCollection<TInput>, TOutput>): Promise<TOutput | null>;
     lastOr<TOutput extends TInput, TExtended = TInput>(settings: AsyncFindOrSettings<TInput, IAsyncCollection<TInput>, TOutput, TExtended>): Promise<TOutput | TExtended>;
     lastOrFail<TOutput extends TInput>(settings?: AsyncFindSettings<TInput, IAsyncCollection<TInput>, TOutput>): Promise<TOutput>;
-    before(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): Promise<TInput | null>;
-    beforeOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): Promise<TInput | TExtended>;
-    beforeOrFail(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): Promise<TInput>;
-    after(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): Promise<TInput | null>;
-    afterOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): Promise<TInput | TExtended>;
-    afterOrFail(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): Promise<TInput>;
-    sole<TOutput extends TInput>(filter: AsyncFilter<TInput, IAsyncCollection<TInput>, TOutput>, throwOnNumberLimit?: boolean): Promise<TOutput>;
+    before(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): Promise<TInput | null>;
+    beforeOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): Promise<TInput | TExtended>;
+    beforeOrFail(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): Promise<TInput>;
+    after(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): Promise<TInput | null>;
+    afterOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): Promise<TInput | TExtended>;
+    afterOrFail(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): Promise<TInput>;
+    sole<TOutput extends TInput>(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>, throwOnIndexOverflow?: boolean): Promise<TOutput>;
     nth(step: number): IAsyncCollection<TInput>;
     delay(timeInMs: number): IAsyncCollection<TInput>;
     abort(signal: AbortSignal): IAsyncCollection<TInput>;
     timeout(timeInMs: number): IAsyncCollection<TInput>;
-    count(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): Promise<number>;
-    size(throwOnNumberLimit?: boolean): Promise<number>;
-    empty(): Promise<boolean>;
-    notEmpty(): Promise<boolean>;
-    search(filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): Promise<number>;
-    forEach(callback: AsyncForEach<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit?: boolean): Promise<void>;
+    count(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): Promise<number>;
+    size(throwOnIndexOverflow?: boolean): Promise<number>;
+    isEmpty(): Promise<boolean>;
+    isNotEmpty(): Promise<boolean>;
+    searchFirst(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): Promise<number>;
+    searchLast(filter: AsyncPredicate<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): Promise<number>;
+    forEach(callback: AsyncForEach<TInput, IAsyncCollection<TInput>>, throwOnIndexOverflow?: boolean): Promise<void>;
     toArray(): Promise<TInput[]>;
 }

package/dist/types/collection/iterable-collection/_shared/_module.d.ts

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

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/chunk-iterable.d.ts

@@ -1,4 +1,7 @@
 import { type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class ChunkIterable<TInput> implements Iterable<ICollection<TInput>> {
     private collection;
     private chunkSize;

package/dist/types/collection/iterable-collection/_shared/chunk-whilte-iterable.d.ts

@@ -0,0 +1,12 @@
+import { type Predicate, type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class ChunkWhileIterable<TInput> implements Iterable<ICollection<TInput>> {
+    private collection;
+    private predicateFn;
+    private throwOnIndexOverflow;
+    private makeCollection;
+    constructor(collection: ICollection<TInput>, predicateFn: Predicate<TInput, ICollection<TInput>>, throwOnIndexOverflow: boolean, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
+    [Symbol.iterator](): Iterator<ICollection<TInput>>;
+}

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/collapse-iterable.d.ts

@@ -1,4 +1,7 @@
 import { type Collapse, type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class CollapseIterable<TInput> implements Iterable<Collapse<TInput>> {
     private collection;
     constructor(collection: ICollection<TInput>);

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/count-by-iterable.d.ts

@@ -1,8 +1,11 @@
 import { type ICollection, type Map, type RecordItem } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class CountByIterable<TInput, TOutput = TInput> implements Iterable<RecordItem<TOutput, number>> {
     private collection;
-    private callback;
-    private throwOnNumberLimit;
-    constructor(collection: ICollection<TInput>, callback: Map<TInput, ICollection<TInput>, TOutput>, throwOnNumberLimit: boolean);
+    private selectFn;
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, selectFn: Map<TInput, ICollection<TInput>, TOutput>, throwOnIndexOverflow: boolean);
     [Symbol.iterator](): Iterator<RecordItem<TOutput, number>>;
 }

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/cross-join-iterable.d.ts

@@ -1,4 +1,7 @@
 import { type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class CrossJoinIterable<TInput, TExtended = TInput> implements Iterable<ICollection<TInput | TExtended>> {
     private collection;
     private iterables;

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/entries-iterable.d.ts

@@ -1,7 +1,10 @@
 import { type RecordItem } from "../../../contracts/collection/_shared";
+/**
+ * @internal
+ */
 export declare class EntriesIterable<TInput> implements Iterable<RecordItem<number, TInput>> {
     private iterable;
-    private throwOnNumberLimit;
-    constructor(iterable: Iterable<TInput>, throwOnNumberLimit: boolean);
+    private throwOnIndexOverflow;
+    constructor(iterable: Iterable<TInput>, throwOnIndexOverflow: boolean);
     [Symbol.iterator](): Iterator<RecordItem<number, TInput>>;
 }

package/dist/types/collection/iterable-collection/_shared/filter-iterable.d.ts

@@ -0,0 +1,11 @@
+import { type Predicate, type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class FilterIterable<TInput, TOutput extends TInput> implements Iterable<TOutput> {
+    private collection;
+    private predicateFn;
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>, throwOnIndexOverflow: boolean);
+    [Symbol.iterator](): Iterator<TOutput>;
+}

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/flat-map-iterable.d.ts

@@ -1,8 +1,11 @@
 import { type ICollection, type Map } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class FlatMapIterable<TInput, TOutput> implements Iterable<TOutput> {
     private collection;
-    private map;
-    private throwOnNumberLimit;
-    constructor(collection: ICollection<TInput>, map: Map<TInput, ICollection<TInput>, Iterable<TOutput>>, throwOnNumberLimit: boolean);
+    private mapFn;
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, mapFn: Map<TInput, ICollection<TInput>, Iterable<TOutput>>, throwOnIndexOverflow: boolean);
     [Symbol.iterator](): Iterator<TOutput>;
 }

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/group-by-iterable.d.ts

@@ -1,9 +1,12 @@
 import { type ICollection, type Map, type RecordItem } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class GroupByIterable<TInput, TOutput = TInput> implements Iterable<RecordItem<TOutput, ICollection<TInput>>> {
     private collection;
-    private callback;
-    private throwOnNumberLimit;
+    private selectFn;
+    private throwOnIndexOverflow;
     private makeCollection;
-    constructor(collection: ICollection<TInput>, callback: Map<TInput, ICollection<TInput>, TOutput>, throwOnNumberLimit: boolean, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
+    constructor(collection: ICollection<TInput>, selectFn: Map<TInput, ICollection<TInput>, TOutput>, throwOnIndexOverflow: boolean, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
     [Symbol.iterator](): Iterator<RecordItem<TOutput, ICollection<TInput>>>;
 }

package/dist/types/collection/iterable-collection/_shared/insert-after-iterable.d.ts

@@ -0,0 +1,12 @@
+import { type Predicate, type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class InsertAfterIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
+    private collection;
+    private predicateFn;
+    private iterable;
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, predicateFn: Predicate<TInput, ICollection<TInput>>, iterable: Iterable<TInput | TExtended>, throwOnIndexOverflow: boolean);
+    [Symbol.iterator](): Iterator<TInput | TExtended>;
+}

package/dist/types/collection/iterable-collection/_shared/insert-before-iterable.d.ts

@@ -0,0 +1,12 @@
+import { type Predicate, type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class InsertBeforeIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
+    private collection;
+    private predicateFn;
+    private iterable;
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, predicateFn: Predicate<TInput, ICollection<TInput>>, iterable: Iterable<TInput | TExtended>, throwOnIndexOverflow: boolean);
+    [Symbol.iterator](): Iterator<TInput | TExtended>;
+}

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/map-iterable.d.ts

@@ -1,8 +1,11 @@
 import { type ICollection, type Map } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class MapIterable<TInput, TOutput> implements Iterable<TOutput> {
     private collection;
-    private map;
-    private throwOnNumberLimit;
-    constructor(collection: ICollection<TInput>, map: Map<TInput, ICollection<TInput>, TOutput>, throwOnNumberLimit: boolean);
+    private mapFn;
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, mapFn: Map<TInput, ICollection<TInput>, TOutput>, throwOnIndexOverflow: boolean);
     [Symbol.iterator](): Iterator<TOutput>;
 }

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/merge-iterable.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @internal
+ */
 export declare class MergeIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
     private iterableA;
     private iterableB;

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/pad-end-iterable.d.ts

@@ -1,4 +1,7 @@
 import { type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class PadEndIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
     private collection;
     private maxLength;

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/pad-start-iterable.d.ts

@@ -1,4 +1,7 @@
 import { type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class PadStartIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
     private collection;
     private maxLength;

package/dist/types/collection/iterable-collection/_shared/partion-iterable.d.ts

@@ -0,0 +1,12 @@
+import { type Predicate, type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class PartionIterable<TInput> implements Iterable<ICollection<TInput>> {
+    private collection;
+    private predicateFn;
+    private throwOnIndexOverflow;
+    private makeCollection;
+    constructor(collection: ICollection<TInput>, predicateFn: Predicate<TInput, ICollection<TInput>>, throwOnIndexOverflow: boolean, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
+    [Symbol.iterator](): Iterator<ICollection<TInput>>;
+}

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/repeat-iterable.d.ts

@@ -1,4 +1,7 @@
 import { type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class RepeatIterable<TInput> implements Iterable<TInput> {
     private collection;
     private amount;

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/reverse-iterable.d.ts

@@ -1,9 +1,12 @@
 import { type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class ReverseIterable<TInput> implements Iterable<TInput> {
     private collection;
     private chunkSize;
-    private throwOnNumberLimit;
+    private throwOnIndexOverflow;
     private makeCollection;
-    constructor(collection: ICollection<TInput>, chunkSize: number, throwOnNumberLimit: boolean, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
+    constructor(collection: ICollection<TInput>, chunkSize: number, throwOnIndexOverflow: boolean, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
     [Symbol.iterator](): Iterator<TInput>;
 }

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/shuffle-iterable.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @internal
+ */
 export declare class ShuffleIterable<TInput> implements Iterable<TInput> {
     private iterable;
     constructor(iterable: Iterable<TInput>);

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/skip-iterable.d.ts

@@ -1,8 +1,11 @@
 import { type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class SkipIterable<TInput> implements Iterable<TInput> {
     private collection;
     private offset;
-    private throwOnNumberLimit;
-    constructor(collection: ICollection<TInput>, offset: number, throwOnNumberLimit: boolean);
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, offset: number, throwOnIndexOverflow: boolean);
     [Symbol.iterator](): Iterator<TInput>;
 }

package/dist/types/collection/iterable-collection/_shared/skip-until-iterable.d.ts

@@ -0,0 +1,11 @@
+import { type Predicate, type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class SkipUntilIterable<TInput> implements Iterable<TInput> {
+    private collection;
+    private predicateFn;
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, predicateFn: Predicate<TInput, ICollection<TInput>>, throwOnIndexOverflow: boolean);
+    [Symbol.iterator](): Iterator<TInput>;
+}

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/slice-iterable.d.ts

@@ -1,9 +1,12 @@
 import { type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class SliceIterable<TInput> implements Iterable<TInput> {
     private collection;
     private start;
     private end;
-    private throwOnNumberLimit;
-    constructor(collection: ICollection<TInput>, start: number | undefined, end: number | undefined, throwOnNumberLimit: boolean);
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, start: number | undefined, end: number | undefined, throwOnIndexOverflow: boolean);
     [Symbol.iterator](): Iterator<TInput>;
 }

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/sliding-iterable.d.ts

@@ -1,9 +1,12 @@
 import { type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class SlidingIteralbe<TInput> implements Iterable<ICollection<TInput>> {
     private collection;
     private chunkSize;
     private step;
-    private throwOnNumberLimit;
-    constructor(collection: ICollection<TInput>, chunkSize: number, step: number, throwOnNumberLimit: boolean);
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, chunkSize: number, step: number, throwOnIndexOverflow: boolean);
     [Symbol.iterator](): Iterator<ICollection<TInput>>;
 }

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/sort-iterable.d.ts

@@ -1,7 +1,10 @@
 import { type Comparator } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class SortIterable<TInput> implements Iterable<TInput> {
     private iterable;
-    private compare?;
-    constructor(iterable: Iterable<TInput>, compare?: Comparator<TInput> | undefined);
+    private comparator?;
+    constructor(iterable: Iterable<TInput>, comparator?: Comparator<TInput> | undefined);
     [Symbol.iterator](): Iterator<TInput>;
 }

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/split-iterable.d.ts

@@ -1,9 +1,12 @@
 import { type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class SplitIterable<TInput> implements Iterable<ICollection<TInput>> {
     private collection;
     private chunkAmount;
-    private throwOnNumberLimit;
+    private throwOnIndexOverflow;
     private makeCollection;
-    constructor(collection: ICollection<TInput>, chunkAmount: number, throwOnNumberLimit: boolean, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
+    constructor(collection: ICollection<TInput>, chunkAmount: number, throwOnIndexOverflow: boolean, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
     [Symbol.iterator](): Iterator<ICollection<TInput>>;
 }

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/take-iterable.d.ts

@@ -1,8 +1,11 @@
 import { type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class TakeIterable<TInput> implements Iterable<TInput> {
     private collection;
     private limit;
-    private throwOnNumberLimit;
-    constructor(collection: ICollection<TInput>, limit: number, throwOnNumberLimit: boolean);
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, limit: number, throwOnIndexOverflow: boolean);
     [Symbol.iterator](): Iterator<TInput>;
 }

package/dist/types/collection/iterable-collection/_shared/take-until-iterable.d.ts

@@ -0,0 +1,11 @@
+import { type Predicate, type ICollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class TakeUntilIterable<TInput> implements Iterable<TInput> {
+    private collection;
+    private predicateFn;
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, predicateFn: Predicate<TInput, ICollection<TInput>>, throwOnIndexOverflow: boolean);
+    [Symbol.iterator](): Iterator<TInput>;
+}

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/tap-iterable.d.ts

@@ -1,4 +1,7 @@
 import { type ICollection, type Tap } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class TapIterable<TInput> implements Iterable<TInput> {
     private collection;
     private callback;

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/unique-iterable.d.ts

@@ -1,8 +1,11 @@
 import { type ICollection, type Map } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class UniqueIterable<TInput, TOutput> implements Iterable<TInput> {
     private collection;
     private callback;
-    private throwOnNumberLimit;
-    constructor(collection: ICollection<TInput>, callback: Map<TInput, ICollection<TInput>, TOutput>, throwOnNumberLimit: boolean);
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, callback: Map<TInput, ICollection<TInput>, TOutput>, throwOnIndexOverflow: boolean);
     [Symbol.iterator](): Iterator<TInput>;
 }

package/dist/types/collection/iterable-collection/_shared/update-iterable.d.ts

@@ -0,0 +1,12 @@
+import { type Predicate, type ICollection, type Map, type UpdatedItem } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class UpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements Iterable<UpdatedItem<TInput, TFilterOutput, TMapOutput>> {
+    private collection;
+    private predicateFn;
+    private mapFn;
+    private throwOnIndexOverflow;
+    constructor(collection: ICollection<TInput>, predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>, throwOnIndexOverflow: boolean);
+    [Symbol.iterator](): Iterator<UpdatedItem<TInput, TFilterOutput, TMapOutput>>;
+}

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/when-iterable.d.ts

@@ -1,4 +1,7 @@
 import { type ICollection, type Modifier } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class WhenIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
     private collection;
     private condition;

package/dist/types/collection/iterable-collection/{iterable-helpers → _shared}/zip-iterable.d.ts

@@ -1,4 +1,7 @@
 import { type RecordItem } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
 export declare class ZipIterable<TInput, TExtended> implements Iterable<RecordItem<TInput, TExtended>> {
     private iterableA;
     private iterableB;