itertools-ts/lib/tools.d.ts

Extended itertools port for TypeScript and JavaScript. Provides a huge set of functions for working with iterable collections (including async ones)

import { ZipTuple } from "./types";
export declare enum MultipleIterationMode {
    SHORTEST = 0,
    LONGEST = 1,
    STRICT_EQUAL = 2
}
/**
 * Creates iterable instance to iterate several iterables simultaneously.
 *
 * @param mode shortest, longest or strict equal
 * @param iterables
 * @param noValueFiller
 * @param iterables
 */
export declare function createMultipleIterator<T extends Array<Iterable<unknown> | Iterator<unknown>>, F>(mode: MultipleIterationMode, noValueFiller: F, ...iterables: T): Iterable<ZipTuple<T, F>>;
/**
 * Creates async iterable instance to iterate several iterables simultaneously.
 *
 * @param mode shortest, longest or strict equal
 * @param iterables
 * @param noValueFiller
 * @param iterables
 */
export declare function createAsyncMultipleIterator<T extends Array<AsyncIterable<unknown> | AsyncIterator<unknown> | Iterable<unknown> | Iterator<unknown>>, F>(mode: MultipleIterationMode, noValueFiller: F, ...iterables: T): AsyncIterable<ZipTuple<T, F>>;
/**
 * Internal class for counting unique values usage.
 */
export declare class UsageMap {
    private addedMap;
    private deletedMap;
    /**
     * Adds new usage of value by given owner.
     *
     * @param value
     * @param owner
     */
    addUsage(value: unknown, owner: string): void;
    /**
     * Removes usage of value.
     *
     * @param value
     */
    deleteUsage(value: unknown): void;
    /**
     * Returns owners count of given value.
     *
     * @param value
     */
    getOwnersCount(value: unknown): number;
    /**
     * Returns usages count of given value.
     *
     * @param value
     * @param maxOwnersCount
     */
    getUsagesCount(value: unknown, maxOwnersCount?: number): number;
}
/**
 * No value filler monad.
 */
export declare class NoValueMonad {
}
/**
 * Internal tool for duplicating another iterators using cache.
 */
export declare class TeeIterator<T> {
    private iterator;
    private related;
    private positions;
    private cache;
    private lastCacheIndex;
    private isValid;
    /**
     * TeeIterator constructor
     *
     * @param iterator
     * @param relatedCount
     */
    constructor(iterator: Iterator<T>, relatedCount: number);
    /**
     * Returns current value of related iterable.
     *
     * @param relatedIterable
     */
    current(relatedIterable: RelatedIterable<T>): T;
    /**
     * Moves related iterable to the next element.
     *
     * @param relatedIterable
     */
    next(relatedIterable: RelatedIterable<T>): void;
    /**
     * Returns true if related iterable is not done.
     *
     * @param relatedIterable
     */
    valid(relatedIterable: RelatedIterable<T>): boolean;
    /**
     * Returns related iterables list.
     */
    getRelatedIterables(): Array<RelatedIterable<T>>;
    /**
     * Gets and caches the next element of parent iterator.
     *
     * @private
     */
    private cacheNextValue;
    /**
     * Returns current position index of related iterable.
     *
     * @param related
     */
    private getPosition;
}
/**
 * Duplicated iterable.
 */
export declare class RelatedIterable<T> implements IterableIterator<T> {
    private parent;
    private readonly id;
    /**
     * RelatedIterable constructor.
     *
     * @param parentIterable
     * @param id
     */
    constructor(parentIterable: TeeIterator<T>, id: number);
    /**
     * Id getter.
     */
    getId(): number;
    /**
     * Returns true if the iterator is valid.
     */
    valid(): boolean;
    /**
     * Moves the iterator to the next element.
     */
    next(): IteratorResult<T>;
    /**
     * Returns current value of the iterator.
     */
    current(): T | undefined;
    /**
     * Aggregated iterator.
     */
    [Symbol.iterator](): IterableIterator<T>;
}
/**
 * Internal tool for duplicating another async iterators using cache.
 */
export declare class AsyncTeeIterator<T> {
    private iterator;
    private related;
    private positions;
    private cache;
    private lastCacheIndex;
    private isValid;
    private isFirstIteration;
    /**
     * AsyncTeeIterator constructor
     *
     * @param iterator
     * @param relatedCount
     */
    constructor(iterator: AsyncIterator<T>, relatedCount: number);
    /**
     * Returns current value of related iterable.
     *
     * @param relatedIterable
     */
    current(relatedIterable: AsyncRelatedIterable<T>): Promise<T>;
    /**
     * Moves related iterable to the next element.
     *
     * @param relatedIterable
     */
    next(relatedIterable: AsyncRelatedIterable<T>): Promise<void>;
    /**
     * Returns true if related iterable is not done.
     *
     * @param relatedIterable
     */
    valid(relatedIterable: AsyncRelatedIterable<T>): Promise<boolean>;
    /**
     * Returns related iterables list.
     */
    getRelatedIterables(): Array<AsyncRelatedIterable<T>>;
    /**
     * Gets and caches the next element of parent iterator.
     *
     * @private
     */
    private cacheNextValue;
    /**
     * Returns current position index of related iterable.
     *
     * @param related
     */
    private getPosition;
}
/**
 * Duplicated async iterable.
 */
export declare class AsyncRelatedIterable<T> implements AsyncIterableIterator<T> {
    private parent;
    private readonly id;
    /**
     * AsyncRelatedIterable constructor.
     *
     * @param parentIterable
     * @param id
     */
    constructor(parentIterable: AsyncTeeIterator<T>, id: number);
    /**
     * Id getter.
     */
    getId(): number;
    /**
     * Returns true if the iterator is valid.
     */
    valid(): Promise<boolean>;
    /**
     * Moves the iterator to the next element.
     */
    next(): Promise<IteratorResult<T>>;
    /**
     * Returns current value of the iterator.
     */
    current(): Promise<T | undefined>;
    /**
     * Aggregated iterator.
     */
    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
}