Class PageLazyStream<T>

PageLazyStream: Processes entire pages lazily (instead of single items).

This class enables lazy, on-demand processing of paginated data sources. Instead of processing individual elements, it operates on entire pages, which is useful for efficient batch processing.

Features:

  • Lazy Pagination: Fetches pages only when needed.
  • Functional API: Supports map(), filter(), and take() at the page level.
  • Async Generators: Works with API pagination or batch-processing tasks.

Type Parameters

  • T

    The type of elements contained in each page.

Constructors

constructor

Methods

filter map take toArray from

Constructors

constructor

  • new PageLazyStream<T>(generatorFn): PageLazyStream<T>

  • Creates a new PageLazyStream instance.

    Type Parameters

    • T

    Parameters

    • generatorFn: (() => AsyncGenerator<T[], void, unknown>)

      An async generator function producing pages.

        • (): AsyncGenerator<T[], void, unknown>

        • Returns AsyncGenerator<T[], void, unknown>

    Returns PageLazyStream<T>

Methods

filter

  • filter(predicate): PageLazyStream<T>

  • Lazily filters entire pages instead of filtering each individual item.

    Parameters

    • predicate: ((page: T[]) => boolean | Promise<boolean>)

      The filtering function for pages.

        • (page): boolean | Promise<boolean>

        • Parameters

          • page: T[]

          Returns boolean | Promise<boolean>

    Returns PageLazyStream<T>

    • A new filtered PageLazyStream.

    Example

    const filteredPages = pageStream.filter(page => page.length > 2);

map

  • map<U>(fn): PageLazyStream<U>

  • Lazily applies a transformation function to entire pages instead of individual items.

    Type Parameters

    • U

      The transformed type.

    Parameters

    • fn: ((page: T[]) => U[])

      Transformation function applied to pages.

        • (page): U[]

        • Parameters

          • page: T[]

          Returns U[]

    Returns PageLazyStream<U>

    • A new PageLazyStream instance.

    Example

    const mappedPages = pageStream.map(page => page.map(item => item.toUpperCase()));

take

toArray

  • toArray(): Promise<T[][]>

  • Collects all pages into a single array.

    Note: This forces evaluation of all elements (breaking laziness).

    Returns Promise<T[][]>

    • A promise resolving to an array of pages.

    Example

    const allPages = await pageStream.toArray();

Staticfrom

  • from<T>(fn): PageLazyStream<T>

  • Creates a PageLazyStream from an async generator function.

    Type Parameters

    • T

      The type of elements in each page.

    Parameters

    • fn: (() => AsyncGenerator<T[], void, unknown>)

      The generator function.

        • (): AsyncGenerator<T[], void, unknown>

        • Returns AsyncGenerator<T[], void, unknown>

    Returns PageLazyStream<T>

    • A new PageLazyStream instance.

    Example

    async function* fetchPages() {
        let page = 1;
        while (page <= 5) {
            yield [`Item ${page}-1`, `Item ${page}-2`, `Item ${page}-3`];
            page++;
        }
    }
    const pageStream = PageLazyStream.from(fetchPages);

Settings

Member Visibility

On This Page

Constructors
Methods