@daiso-tech/core 0.0.1 → 0.1.1

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

@@ -0,0 +1,9 @@
+import { type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncShuffleIterable<TInput> implements AsyncIterable<TInput> {
+    private collection;
+    constructor(collection: IAsyncCollection<TInput>);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
+}

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

@@ -0,0 +1,11 @@
+import { type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncSkipIterable<TInput> implements AsyncIterable<TInput> {
+    private collection;
+    private limit;
+    private throwOnNumberLimit;
+    constructor(collection: IAsyncCollection<TInput>, limit: number, throwOnNumberLimit: boolean);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
+}

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

@@ -0,0 +1,11 @@
+import { type AsyncFilter, type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncSkipUntilIterable<TInput> implements AsyncIterable<TInput> {
+    private collection;
+    private filter;
+    private throwOnNumberLimit;
+    constructor(collection: IAsyncCollection<TInput>, filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit: boolean);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
+}

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

@@ -0,0 +1,12 @@
+import { type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncSliceIterable<TInput> implements AsyncIterable<TInput> {
+    private collection;
+    private start;
+    private end;
+    private throwOnNumberLimit;
+    constructor(collection: IAsyncCollection<TInput>, start: number | undefined, end: number | undefined, throwOnNumberLimit: boolean);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
+}

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

@@ -0,0 +1,12 @@
+import { type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncSlidingIteralbe<TInput> implements AsyncIterable<IAsyncCollection<TInput>> {
+    private collection;
+    private chunkSize;
+    private step;
+    private throwOnNumberLimit;
+    constructor(collection: IAsyncCollection<TInput>, chunkSize: number, step: number, throwOnNumberLimit: boolean);
+    [Symbol.asyncIterator](): AsyncIterator<IAsyncCollection<TInput>>;
+}

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

@@ -0,0 +1,10 @@
+import { type Comparator, type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncSortIterable<TInput> implements AsyncIterable<TInput> {
+    private collection;
+    private compare?;
+    constructor(collection: IAsyncCollection<TInput>, compare?: Comparator<TInput> | undefined);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
+}

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

@@ -0,0 +1,12 @@
+import { type AsyncIterableValue, type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncSplitIterable<TInput> implements AsyncIterable<IAsyncCollection<TInput>> {
+    private collection;
+    private chunkAmount;
+    private throwOnNumberLimit;
+    private makeCollection;
+    constructor(collection: IAsyncCollection<TInput>, chunkAmount: number, throwOnNumberLimit: boolean, makeCollection: <TInput>(iterable: AsyncIterableValue<TInput>) => IAsyncCollection<TInput>);
+    [Symbol.asyncIterator](): AsyncIterator<IAsyncCollection<TInput>>;
+}

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

@@ -0,0 +1,11 @@
+import { type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncTakeIterable<TInput> implements AsyncIterable<TInput> {
+    private collection;
+    private limit;
+    private throwOnNumberLimit;
+    constructor(collection: IAsyncCollection<TInput>, limit: number, throwOnNumberLimit: boolean);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
+}

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

@@ -0,0 +1,11 @@
+import { type AsyncFilter, type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncTakeUntilIterable<TInput> implements AsyncIterable<TInput> {
+    private collection;
+    private filter;
+    private throwOnNumberLimit;
+    constructor(collection: IAsyncCollection<TInput>, filter: AsyncFilter<TInput, IAsyncCollection<TInput>>, throwOnNumberLimit: boolean);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
+}

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

@@ -0,0 +1,10 @@
+import { type AsyncTap, type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncTapIterable<TInput> implements AsyncIterable<TInput> {
+    private collection;
+    private callback;
+    constructor(collection: IAsyncCollection<TInput>, callback: AsyncTap<IAsyncCollection<TInput>>);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
+}

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

@@ -0,0 +1,10 @@
+import { type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncTimeoutIterable<TInput> implements AsyncIterable<TInput> {
+    private collection;
+    private timeInMs;
+    constructor(collection: IAsyncCollection<TInput>, timeInMs: number);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
+}

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

@@ -0,0 +1,11 @@
+import { type AsyncMap, type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncUniqueIterable<TInput, TOutput> implements AsyncIterable<TInput> {
+    private collection;
+    private callback;
+    private throwOnNumberLimit;
+    constructor(collection: IAsyncCollection<TInput>, callback: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>, throwOnNumberLimit: boolean);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
+}

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

@@ -0,0 +1,12 @@
+import { type AsyncFilter, type AsyncMap, type IAsyncCollection, type UpdatedItem } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncUpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements AsyncIterable<UpdatedItem<TInput, TFilterOutput, TMapOutput>> {
+    private collection;
+    private filter;
+    private map;
+    private throwOnNumberLimit;
+    constructor(collection: IAsyncCollection<TInput>, filter: AsyncFilter<TInput, IAsyncCollection<TInput>, TFilterOutput>, map: AsyncMap<TFilterOutput, IAsyncCollection<TInput>, TMapOutput>, throwOnNumberLimit: boolean);
+    [Symbol.asyncIterator](): AsyncIterator<UpdatedItem<TInput, TFilterOutput, TMapOutput>>;
+}

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

@@ -0,0 +1,11 @@
+import { type AsyncModifier, type IAsyncCollection } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncWhenIterable<TInput, TExtended> implements AsyncIterable<TInput | TExtended> {
+    private collection;
+    private condition;
+    private callback;
+    constructor(collection: IAsyncCollection<TInput>, condition: () => boolean | Promise<boolean>, callback: AsyncModifier<IAsyncCollection<TInput>, IAsyncCollection<TExtended>>);
+    [Symbol.asyncIterator](): AsyncIterator<TInput | TExtended>;
+}

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

@@ -0,0 +1,10 @@
+import { type AsyncIterableValue, type RecordItem } from "../../../contracts/collection/_module";
+/**
+ * @internal
+ */
+export declare class AsyncZipIterable<TInput, TExtended> implements AsyncIterable<RecordItem<TInput, TExtended>> {
+    private iterableA;
+    private iterableB;
+    constructor(iterableA: AsyncIterableValue<TInput>, iterableB: AsyncIterableValue<TExtended>);
+    [Symbol.asyncIterator](): AsyncIterator<RecordItem<TInput, TExtended>>;
+}

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

@@ -0,0 +1 @@
+export * from "../../collection/iterable-collection/iterable-collection";

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

@@ -0,0 +1,89 @@
+import { type Collapse, type Comparator, type Filter, type FindOrSettings, type FindSettings, type ForEach, type GroupBySettings, type ICollection, type JoinSettings, type Lazyable, type Map, type Modifier, type PageSettings, type RecordItem, type ReduceSettings, type ReverseSettings, type SliceSettings, type SlidingSettings, type Tap, type Transform, type UpdatedItem } from "../../contracts/collection/_module";
+import { type EnsureType } from "../../types";
+/**
+ * Most methods in IterableCollection are lazy and will only execute when calling methods return values or iterating through an IterableCollection by using for of loop.
+ * @group Collections
+ */
+export declare class IterableCollection<TInput> implements ICollection<TInput> {
+    private iterable;
+    private static THROW_ON_NUMBER_LIMIT;
+    private static DEFAULT_CHUNK_SIZE;
+    private static makeCollection;
+    constructor(iterable: Iterable<TInput>);
+    [Symbol.iterator](): Iterator<TInput>;
+    iterator(): Iterator<TInput, void>;
+    entries(throwOnNumberLimit?: boolean): ICollection<RecordItem<number, TInput>>;
+    keys(throwOnNumberLimit?: boolean): ICollection<number>;
+    values(): ICollection<TInput>;
+    filter<TOutput extends TInput>(filter: Filter<TInput, ICollection<TInput>, TOutput>, throwOnNumberLimit?: boolean): ICollection<TOutput>;
+    map<TOutput>(map: Map<TInput, ICollection<TInput>, TOutput>, throwOnNumberLimit?: boolean): ICollection<TOutput>;
+    reduce<TOutput = TInput>(settings: ReduceSettings<TInput, ICollection<TInput>, TOutput>): TOutput;
+    join(settings?: JoinSettings): string;
+    collapse(): ICollection<Collapse<TInput>>;
+    flatMap<TOutput>(map: Map<TInput, ICollection<TInput>, Iterable<TOutput>>, throwOnNumberLimit?: boolean): ICollection<TOutput>;
+    update<TFilterOutput extends TInput, TMapOutput>(filter: Filter<TInput, ICollection<TInput>, TFilterOutput>, map: Map<TFilterOutput, ICollection<TInput>, TMapOutput>, throwOnNumberLimit?: boolean): ICollection<UpdatedItem<TInput, TFilterOutput, TMapOutput>>;
+    page(settings: PageSettings): ICollection<TInput>;
+    sum(throwOnNumberLimit?: boolean): EnsureType<TInput, number>;
+    average(throwOnNumberLimit?: boolean): EnsureType<TInput, number>;
+    median(throwOnNumberLimit?: boolean): EnsureType<TInput, number>;
+    min(): EnsureType<TInput, number>;
+    max(): EnsureType<TInput, number>;
+    percentage(filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): number;
+    some<TOutput extends TInput>(filter: Filter<TInput, ICollection<TInput>, TOutput>, throwOnNumberLimit?: boolean): boolean;
+    every<TOutput extends TInput>(filter: Filter<TInput, ICollection<TInput>, TOutput>, throwOnNumberLimit?: boolean): boolean;
+    take(limit: number, throwOnNumberLimit?: boolean): ICollection<TInput>;
+    takeUntil(filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): ICollection<TInput>;
+    takeWhile(filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): ICollection<TInput>;
+    skip(offset: number, throwOnNumberLimit?: boolean): ICollection<TInput>;
+    skipUntil(filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): ICollection<TInput>;
+    skipWhile<TOutput extends TInput>(filter: Filter<TInput, ICollection<TInput>, TOutput>, throwOnNumberLimit?: boolean): ICollection<TInput>;
+    when<TExtended = TInput>(condition: boolean, callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    whenEmpty<TExtended = TInput>(callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    whenNot<TExtended = TInput>(condition: boolean, callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    whenNotEmpty<TExtended = TInput>(callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    pipe<TOutput = TInput>(callback: Transform<ICollection<TInput>, TOutput>): TOutput;
+    tap(callback: Tap<ICollection<TInput>>): ICollection<TInput>;
+    chunk(chunkSize: number): ICollection<ICollection<TInput>>;
+    chunkWhile(filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): ICollection<ICollection<TInput>>;
+    split(chunkAmount: number, throwOnNumberLimit?: boolean): ICollection<ICollection<TInput>>;
+    partition(filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): ICollection<ICollection<TInput>>;
+    sliding(settings: SlidingSettings): ICollection<ICollection<TInput>>;
+    groupBy<TOutput = TInput>(settings?: GroupBySettings<TInput, ICollection<TInput>, TOutput>): ICollection<RecordItem<TOutput, ICollection<TInput>>>;
+    countBy<TOutput = TInput>(settings?: GroupBySettings<TInput, ICollection<TInput>, TOutput>): ICollection<RecordItem<TOutput, number>>;
+    unique<TOutput>(settings?: GroupBySettings<TInput, ICollection<TInput>, TOutput>): ICollection<TInput>;
+    difference<TOutput = TInput>(iterable: Iterable<TInput>, map?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<TInput>;
+    repeat(amount: number): ICollection<TInput>;
+    padStart<TExtended = TInput>(maxLength: number, fillItems: Iterable<TExtended>): ICollection<TInput | TExtended>;
+    padEnd<TExtended = TInput>(maxLength: number, fillItems: Iterable<TExtended>): ICollection<TInput | TExtended>;
+    slice(settings?: SliceSettings): ICollection<TInput>;
+    prepend<TExtended = TInput>(iterable: Iterable<TInput | TExtended>): ICollection<TInput | TExtended>;
+    append<TExtended = TInput>(iterable: Iterable<TInput | TExtended>): ICollection<TInput | TExtended>;
+    insertBefore<TExtended = TInput>(filter: Filter<TInput, ICollection<TInput>>, iterable: Iterable<TInput | TExtended>, throwOnNumberLimit?: boolean): ICollection<TInput | TExtended>;
+    insertAfter<TExtended = TInput>(filter: Filter<TInput, ICollection<TInput>>, iterable: Iterable<TInput | TExtended>, throwOnNumberLimit?: boolean): ICollection<TInput | TExtended>;
+    crossJoin<TExtended = TInput>(...iterables: Array<Iterable<TExtended>>): ICollection<ICollection<TInput | TExtended>>;
+    zip<TExtended>(iterable: Iterable<TExtended>): ICollection<RecordItem<TInput, TExtended>>;
+    sort(compare?: Comparator<TInput>): ICollection<TInput>;
+    reverse(settings?: ReverseSettings): ICollection<TInput>;
+    shuffle(): ICollection<TInput>;
+    first<TOutput extends TInput>(settings?: FindSettings<TInput, ICollection<TInput>, TOutput>): TOutput | null;
+    firstOr<TOutput extends TInput, TExtended = TInput>(settings: FindOrSettings<TInput, ICollection<TInput>, TOutput, TExtended>): TOutput | TExtended;
+    firstOrFail<TOutput extends TInput>(settings?: FindSettings<TInput, ICollection<TInput>, TOutput>): TOutput;
+    last<TOutput extends TInput>(settings?: FindSettings<TInput, ICollection<TInput>, TOutput>): TOutput | null;
+    lastOr<TOutput extends TInput, TExtended = TInput>(settings: FindOrSettings<TInput, ICollection<TInput>, TOutput, TExtended>): TOutput | TExtended;
+    lastOrFail<TOutput extends TInput>(settings?: FindSettings<TInput, ICollection<TInput>, TOutput>): TOutput;
+    before(filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): TInput | null;
+    beforeOr<TExtended = TInput>(defaultValue: Lazyable<TExtended>, filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): TInput | TExtended;
+    beforeOrFail(filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): TInput;
+    after(filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): TInput | null;
+    afterOr<TExtended = TInput>(defaultValue: Lazyable<TExtended>, filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): TInput | TExtended;
+    afterOrFail(filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): TInput;
+    sole<TOutput extends TInput>(filter: Filter<TInput, ICollection<TInput>, TOutput>, throwOnNumberLimit?: boolean): TOutput;
+    nth(step: number): ICollection<TInput>;
+    count(filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): number;
+    size(throwOnNumberLimit?: boolean): number;
+    empty(): boolean;
+    notEmpty(): boolean;
+    search(filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): number;
+    forEach(callback: ForEach<TInput, ICollection<TInput>>, throwOnNumberLimit?: boolean): void;
+    toArray(): TInput[];
+}

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

@@ -0,0 +1,32 @@
+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/dist/types/collection/iterable-collection/iterable-helpers/chunk-iterable.d.ts

@@ -0,0 +1,8 @@
+import { type ICollection } from "../../../contracts/collection/_module";
+export declare class ChunkIterable<TInput> implements Iterable<ICollection<TInput>> {
+    private collection;
+    private chunkSize;
+    private readonly makeCollection;
+    constructor(collection: ICollection<TInput>, chunkSize: number, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
+    [Symbol.iterator](): Iterator<ICollection<TInput>>;
+}

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

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

package/dist/types/collection/iterable-collection/iterable-helpers/collapse-iterable.d.ts

@@ -0,0 +1,6 @@
+import { type Collapse, type ICollection } from "../../../contracts/collection/_module";
+export declare class CollapseIterable<TInput> implements Iterable<Collapse<TInput>> {
+    private collection;
+    constructor(collection: ICollection<TInput>);
+    [Symbol.iterator](): Iterator<Collapse<TInput>>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/count-by-iterable.d.ts

@@ -0,0 +1,8 @@
+import { type ICollection, type Map, type RecordItem } from "../../../contracts/collection/_module";
+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);
+    [Symbol.iterator](): Iterator<RecordItem<TOutput, number>>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/cross-join-iterable.d.ts

@@ -0,0 +1,8 @@
+import { type ICollection } from "../../../contracts/collection/_module";
+export declare class CrossJoinIterable<TInput, TExtended = TInput> implements Iterable<ICollection<TInput | TExtended>> {
+    private collection;
+    private iterables;
+    private makeCollection;
+    constructor(collection: ICollection<TInput>, iterables: Array<Iterable<TExtended>>, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
+    [Symbol.iterator](): Iterator<ICollection<TInput | TExtended>>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/entries-iterable.d.ts

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

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

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

package/dist/types/collection/iterable-collection/iterable-helpers/flat-map-iterable.d.ts

@@ -0,0 +1,8 @@
+import { type ICollection, type Map } from "../../../contracts/collection/_module";
+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);
+    [Symbol.iterator](): Iterator<TOutput>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/group-by-iterable.d.ts

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

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

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

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

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

package/dist/types/collection/iterable-collection/iterable-helpers/map-iterable.d.ts

@@ -0,0 +1,8 @@
+import { type ICollection, type Map } from "../../../contracts/collection/_module";
+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);
+    [Symbol.iterator](): Iterator<TOutput>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/merge-iterable.d.ts

@@ -0,0 +1,6 @@
+export declare class MergeIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
+    private iterableA;
+    private iterableB;
+    constructor(iterableA: Iterable<TInput>, iterableB: Iterable<TExtended>);
+    [Symbol.iterator](): Iterator<TInput | TExtended>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/pad-end-iterable.d.ts

@@ -0,0 +1,9 @@
+import { type ICollection } from "../../../contracts/collection/_module";
+export declare class PadEndIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
+    private collection;
+    private maxLength;
+    private fillItems;
+    private makeCollection;
+    constructor(collection: ICollection<TInput>, maxLength: number, fillItems: Iterable<TExtended>, makeCollection: <TInput>(iterable: Iterable<TInput | TExtended>) => ICollection<TInput | TExtended>);
+    [Symbol.iterator](): Iterator<TInput | TExtended>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/pad-start-iterable.d.ts

@@ -0,0 +1,9 @@
+import { type ICollection } from "../../../contracts/collection/_module";
+export declare class PadStartIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
+    private collection;
+    private maxLength;
+    private fillItems;
+    private makeCollection;
+    constructor(collection: ICollection<TInput>, maxLength: number, fillItems: Iterable<TExtended>, makeCollection: <TInput>(iterable: Iterable<TInput | TExtended>) => ICollection<TInput | TExtended>);
+    [Symbol.iterator](): Iterator<TInput | TExtended>;
+}

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

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

package/dist/types/collection/iterable-collection/iterable-helpers/repeat-iterable.d.ts

@@ -0,0 +1,8 @@
+import { type ICollection } from "../../../contracts/collection/_module";
+export declare class RepeatIterable<TInput> implements Iterable<TInput> {
+    private collection;
+    private amount;
+    private makeCollection;
+    constructor(collection: ICollection<TInput>, amount: number, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
+    [Symbol.iterator](): Iterator<TInput>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/reverse-iterable.d.ts

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

package/dist/types/collection/iterable-collection/iterable-helpers/shuffle-iterable.d.ts

@@ -0,0 +1,5 @@
+export declare class ShuffleIterable<TInput> implements Iterable<TInput> {
+    private iterable;
+    constructor(iterable: Iterable<TInput>);
+    [Symbol.iterator](): Iterator<TInput>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/skip-iterable.d.ts

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

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

@@ -0,0 +1,8 @@
+import { type Filter, type ICollection } from "../../../contracts/collection/_module";
+export declare class SkipUntilIterable<TInput> implements Iterable<TInput> {
+    private collection;
+    private filter;
+    private throwOnNumberLimit;
+    constructor(collection: ICollection<TInput>, filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit: boolean);
+    [Symbol.iterator](): Iterator<TInput>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/slice-iterable.d.ts

@@ -0,0 +1,9 @@
+import { type ICollection } from "../../../contracts/collection/_module";
+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);
+    [Symbol.iterator](): Iterator<TInput>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/sliding-iterable.d.ts

@@ -0,0 +1,9 @@
+import { type ICollection } from "../../../contracts/collection/_module";
+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);
+    [Symbol.iterator](): Iterator<ICollection<TInput>>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/sort-iterable.d.ts

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

package/dist/types/collection/iterable-collection/iterable-helpers/split-iterable.d.ts

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

package/dist/types/collection/iterable-collection/iterable-helpers/take-iterable.d.ts

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

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

@@ -0,0 +1,8 @@
+import { type Filter, type ICollection } from "../../../contracts/collection/_module";
+export declare class TakeUntilIterable<TInput> implements Iterable<TInput> {
+    private collection;
+    private filter;
+    private throwOnNumberLimit;
+    constructor(collection: ICollection<TInput>, filter: Filter<TInput, ICollection<TInput>>, throwOnNumberLimit: boolean);
+    [Symbol.iterator](): Iterator<TInput>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/tap-iterable.d.ts

@@ -0,0 +1,7 @@
+import { type ICollection, type Tap } from "../../../contracts/collection/_module";
+export declare class TapIterable<TInput> implements Iterable<TInput> {
+    private collection;
+    private callback;
+    constructor(collection: ICollection<TInput>, callback: Tap<ICollection<TInput>>);
+    [Symbol.iterator](): Iterator<TInput>;
+}