@af-utils/react-virtual-headless/lib/models/VirtualScroller/index.d.ts

React components for rendering large scrollable data

import { Event } from "../../constants/index";
import type { ScrollElement, VirtualScrollerInitialParams, VirtualScrollerRuntimeParams } from "../../types";
declare class VirtualScroller {
    private _scrollElementSizeKey;
    private _scrollKey;
    private _resizeObserverSizeKey;
    private _scrollToKey;
    private _alignedScrollPos;
    private _scrollElementOffset;
    private _rawScrollSize;
    private _stickyOffset;
    private _itemCount;
    private _availableWidgetSize;
    private _scrollToTimer;
    private _overscanCount;
    private _estimatedItemSize;
    private _scrollElement;
    private _initialElement;
    private _itemSizes;
    private _fTree;
    /**
     * Most significant bit of this._itemCount;
     * caching it to avoid Math.clz32 calculations on every getIndex call
     */
    private _msb;
    /** Scroll direction */
    horizontal: boolean;
    /** Sum of all item sizes */
    scrollSize: number;
    /** Items range start */
    from: number;
    /** Items range end */
    to: number;
    /** Hash of item sizes. Changed when at least one visible item is resized. */
    sizesHash: number;
    private _elToIdx;
    private _idxToEl;
    private _stickyElements;
    private _stickyElementsSizes;
    private _StickyElResizeObserver;
    private _ElResizeObserver;
    private _EventsList;
    /**
     * Update property names for resize events, dimensions and scroll position extraction
     *
     * @remarks
     *
     * `window.resize` event must be used for window scroller, `ResizeObserver` must be used in other cases.
     * `offsetWidth` is used as item size in horizontal mode, `offsetHeight` - in vertical.
     */
    private _updatePropertyKeys;
    private _handleScrollElementResize;
    private _updateStickyOffset;
    private _unobserveResize;
    constructor(params?: VirtualScrollerInitialParams);
    /**
     * Subscribe to model events
     *
     * @param callBack - event to be triggered
     * @param events - events to subscribe
     *
     * @returns unsubscribe function
     */
    on(callBack: () => void, events: Event[]): () => void;
    /**
     * Call all `event` subscribers
     * @param event - event to emit
     */
    private _run;
    /**
     * Get item index by pixel offset
     *
     * @param offset - pixel offset
     * @returns item index
     */
    getIndex(offset: number): number;
    /**
     * Get pixel offset by item index
     *
     * @param index - item index
     * @returns pixel offset
     */
    getOffset(index: number): number;
    /**
     * @param itemIndex - item index
     * @returns last cached item size
     */
    getSize(itemIndex: number): number;
    /**
     * Get snapshot of current scroll position.
     *
     * @remarks
     *
     * For example `5.3` stands for item at index `5` + `30%` of its size.
     * Used to remember scroll position before prepending elements.
     *
     * @returns visible item index (double number)
     */
    get visibleFrom(): number;
    /**
     * Synchronize current scroll position with visible range
     */
    private _syncScrollPosition;
    setScroller: (element: ScrollElement | null) => void;
    setContainer: (element: Element | null) => void;
    _updateScrollerOffsetRaw(): number;
    updateScrollerOffset(): void;
    /**
     * Start observing size of `element` at `index`. Observing is finished if element is falsy.
     * @param index - item index
     * @param element - element for item
     */
    el(index: number, element: Element | null): void;
    private _stickyEl;
    /**
     * Start observing size of sticky header `element`. Observing is finished if element is falsy.
     * @param element - header element
     */
    setStickyHeader(element: Element | null): void;
    /**
     * Start observing size of sticky footer `element`. Observing is finished if element is falsy.
     * @param element - footer element
     */
    setStickyFooter(element: Element | null): void;
    /**
     * Get first visible item index (without overscan)
     * @returns first visible item index
     */
    private get _exactFrom();
    /**
     * Get last visible item index (without overscan)
     * @returns last visible item index
     */
    private get _exactTo();
    /**
     * Used to update current visible items range when scrolling down/right;
     * adds overscan reserve forward to reduce rerenders quantity
     */
    private _updateRangeFromEnd;
    /**
     * Used to update current visible items range when scrolling up/left;
     * adds overscan reserve backward to reduce rerenders quantity
     */
    private _updateRangeFromStart;
    /**
     * Scroll to pixel offset
     *
     * @param offset - offset to scroll to
     * @param smooth - should smooth scroll be used
     */
    scrollToOffset(offset: number, smooth?: boolean): void;
    private _attemptToScrollToIndex;
    /**
     * Scroll to item index
     *
     * @param index - item index to scroll to
     * @param smooth - should smooth scroll be used
     */
    scrollToIndex(index: number, smooth?: boolean): void;
    /**
     * Notify model about items quantity change
     * @param itemCount - new items quantity
     */
    setItemCount(itemCount: number): void;
    /**
     * Synchronize runtime parameters
     * @param runtimeParams - runtime parameters
     */
    set({ overscanCount, itemCount, estimatedItemSize }: VirtualScrollerRuntimeParams): void;
}
export default VirtualScroller;
//# sourceMappingURL=index.d.ts.map