ng-virtual-list 20.2.0 → 20.3.1

package/index.d.ts

@@ -1,5 +1,804 @@
+import * as ng_virtual_list from 'ng-virtual-list';
+import * as _angular_core from '@angular/core';
+import { WritableSignal, TemplateRef, ElementRef, ComponentRef, AfterViewInit, OnInit, OnDestroy, ViewContainerRef } from '@angular/core';
+import { Observable } from 'rxjs';
+
 /**
- * Generated bundle index. Do not edit.
+ * Identifier type
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/types/id.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
  */
-/// <amd-module name="ng-virtual-list" />
-export * from './public-api';
+type Id = string | number;
+
+/**
+ * Area area Interface
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/types/size.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface ISize {
+    /**
+     * Width value.
+     */
+    width: number;
+    /**
+     * Height value.
+     */
+    height: number;
+}
+
+/**
+ * Rectangular area interface
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/types/rect.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IRect extends ISize {
+    /**
+     * X coordinate.
+     */
+    x: number;
+    /**
+     * Y coordinate.
+     */
+    y: number;
+}
+
+/**
+ * Virtual list element model
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/models/item.model.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type IVirtualListItem<E = Object> = E & {
+    /**
+     * Unique identifier of the element.
+     */
+    id: Id;
+    [x: string]: any;
+};
+
+/**
+ * Object with configuration parameters for IRenderVirtualListItem
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/models/render-item-config.model.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ *
+ */
+interface IRenderVirtualListItemConfig {
+    /**
+     * If greater than 0, the element will have a sticky position with the given zIndex.
+     */
+    sticky: number;
+    /**
+     * Specifies whether the element will snap.
+     */
+    snap: boolean;
+    /**
+     * Indicates that the element is snapped.
+     */
+    snapped: boolean;
+    /**
+     * Indicates that the element is being shifted by another snap element.
+     */
+    snappedOut: boolean;
+    /**
+     * Indicates that the element is a vertical list item.
+     */
+    isVertical: boolean;
+    /**
+     * Specifies that the element adapts to the size of its content.
+     */
+    dynamic: boolean;
+    /**
+     * Returns true if the snapping method is advanced
+     */
+    isSnappingMethodAdvanced: boolean;
+    /**
+     * z-index
+     */
+    zIndex: string;
+}
+
+/**
+ * List screen element model
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/models/render-item.model.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IRenderVirtualListItem {
+    /**
+     * Unique identifier of the element.
+     */
+    id: Id;
+    /**
+     * Element metrics.
+     */
+    measures: IRect & {
+        /**
+         * Delta is calculated for Snapping Method.ADVANCED
+         */
+        delta: number;
+    };
+    /**
+     * Element data.
+     */
+    data: IVirtualListItem;
+    /**
+     * Object with configuration parameters for IRenderVirtualListItem.
+     */
+    config: IRenderVirtualListItemConfig;
+}
+
+/**
+ * A value of -1 indicates the direction is up or left (if the list direction is horizontal).
+ * A value of 1 indicates the direction is down or right (if the list direction is horizontal).
+ */
+type ScrollDirection = -1 | 1 | 0;
+
+/**
+ * Interface IScrollEvent.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/models/scroll-event.model.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollEvent {
+    /**
+     * Scroll area offset
+     */
+    scrollSize: number;
+    /**
+     * Full size of the scroll area
+     */
+    scrollWeight: number;
+    /**
+     * Viewport size
+     */
+    size: number;
+    /**
+     * Size of the list of elements
+     */
+    listSize: number;
+    /**
+     * Specifies whether the list orientation is vertical.
+     */
+    isVertical: boolean;
+    /**
+     * A value of -1 indicates the direction is up or left (if the list direction is horizontal).
+     * A value of 1 indicates the direction is down or right (if the list direction is horizontal).
+     */
+    direction: ScrollDirection;
+    /**
+     * If true then indicates that the list has been scrolled to the end.
+     */
+    isStart: boolean;
+    /**
+     * If true then indicates that the list has been scrolled to the end.
+     */
+    isEnd: boolean;
+    /**
+     * Delta of marked and unmarked area
+     */
+    delta: number;
+    /**
+     * Scroll delta
+     */
+    scrollDelta: number;
+}
+
+/**
+ * Dictionary zIndex by id of the list element. If the value is not set or equal to 0, then a simple element is displayed,
+ * if the value is greater than 0, then the sticky position mode is enabled for the element. 1 - position start, 2 - position end.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/models/sticky-map.model.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IVirtualListStickyMap {
+    /**
+     * Sets zIndex for the element ID. If zIndex is greater than 0, then sticky position is applied.
+     * 1 - position start, 2 - position end.
+     */
+    [id: string]: 0 | 1 | 2;
+}
+
+/**
+ * Virtual list elements collection interface
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/models/collection.model.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IVirtualListCollection<E = Object> extends Array<IVirtualListItem<E>> {
+}
+
+/**
+ * Virtual List Item Interface
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/models/-basevirtual-list-item-component.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare abstract class BaseVirtualListItemComponent {
+    abstract get id(): number;
+    abstract data: WritableSignal<IRenderVirtualListItem | undefined>;
+    abstract regular: boolean;
+    abstract set regularLength(v: string);
+    abstract set item(v: IRenderVirtualListItem | null | undefined);
+    abstract get item(): IRenderVirtualListItem | null | undefined;
+    abstract get itemId(): Id | undefined;
+    abstract itemRenderer: WritableSignal<TemplateRef<any> | undefined>;
+    abstract set renderer(v: TemplateRef<any> | undefined);
+    abstract get element(): HTMLElement;
+    protected abstract update(): void;
+    abstract getBounds(): ISize;
+    abstract show(): void;
+    abstract hide(): void;
+}
+
+interface Component$1<T> extends Function {
+    new (...args: any[]): T;
+}
+
+/**
+ * Virtual list item component
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/components/ng-virtual-list-item.component.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class NgVirtualListItemComponent extends BaseVirtualListItemComponent {
+    protected static __nextId: number;
+    protected _id: number;
+    get id(): number;
+    regular: boolean;
+    data: _angular_core.WritableSignal<IRenderVirtualListItem | undefined>;
+    protected _data: IRenderVirtualListItem | undefined;
+    set item(v: IRenderVirtualListItem | undefined);
+    protected _regularLength: string;
+    set regularLength(v: string);
+    get item(): IRenderVirtualListItem | undefined;
+    get itemId(): ng_virtual_list.Id | undefined;
+    itemRenderer: _angular_core.WritableSignal<TemplateRef<any> | undefined>;
+    set renderer(v: TemplateRef<any> | undefined);
+    protected _elementRef: ElementRef<HTMLElement>;
+    get element(): HTMLElement;
+    constructor();
+    protected update(): void;
+    getBounds(): ISize;
+    show(): void;
+    hide(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgVirtualListItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgVirtualListItemComponent, "ng-virtual-list-item", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Virtual list screen elements collection interface
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/models/render-collection.model.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IRenderVirtualListCollection extends Array<IRenderVirtualListItem> {
+}
+
+/**
+ * Axis of the arrangement of virtual list elements.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/enums/directions.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum Directions {
+    /**
+     * Horizontal axis.
+     */
+    HORIZONTAL = "horizontal",
+    /**
+     * Vertical axis.
+     */
+    VERTICAL = "vertical"
+}
+
+/**
+ * Axis of the arrangement of virtual list elements.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/enums/direction.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type Direction = Directions | 'horizontal' | 'vertical';
+
+/**
+ * Snapping method.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/enums/snapping-method.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum SnappingMethods {
+    /**
+     * Normal group rendering.
+     */
+    NORMAL = "normal",
+    /**
+     * The group is rendered on a transparent background. List items below the group are not rendered.
+     */
+    ADVANCED = "advanced"
+}
+
+/**
+ * Snapping method.
+ * 'normal' - Normal group rendering.
+ * 'advanced' - The group is rendered on a transparent background. List items below the group are not rendered.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/enums/snapping-method.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type SnappingMethod = SnappingMethods | 'normal' | 'advanced';
+
+/**
+ * Tracks display items by property
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/utils/tracker.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class Tracker<C extends BaseVirtualListItemComponent = any> {
+    /**
+     * display objects dictionary of indexes by id
+     */
+    private _displayObjectIndexMapById;
+    set displayObjectIndexMapById(v: {
+        [id: number]: number;
+    });
+    get displayObjectIndexMapById(): {
+        [id: number]: number;
+    };
+    /**
+     * Dictionary displayItems propertyNameId by items propertyNameId
+     */
+    private _trackMap;
+    get trackMap(): {
+        [id: string]: number;
+        [id: number]: number;
+    } | null;
+    private _trackingPropertyName;
+    set trackingPropertyName(v: string);
+    constructor(trackingPropertyName: string);
+    /**
+     * tracking by propName
+     */
+    track(items: Array<any>, components: Array<ComponentRef<C>>, snapedComponent: ComponentRef<C> | null | undefined, direction: ScrollDirection): void;
+    untrackComponentByIdProperty(component?: C): void;
+    dispose(): void;
+}
+
+type TEventHandler = (...args: Array<any>) => void;
+/**
+ * Simple event emitter
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/utils/eventEmitter.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class EventEmitter<E = string, H = TEventHandler> {
+    private _listeners;
+    protected _disposed: boolean;
+    constructor();
+    /**
+     * Emits the event
+     */
+    dispatch(event: E, ...args: Array<any>): void;
+    /**
+     * Emits the event async
+     */
+    dispatchAsync(event: E, ...args: Array<any>): void;
+    /**
+     * Returns true if the event listener is already subscribed.
+     */
+    hasEventListener(eventName: E, handler: H): boolean;
+    /**
+     * Add event listener
+     */
+    addEventListener(eventName: E, handler: H): void;
+    /**
+     * Remove event listener
+     */
+    removeEventListener(eventName: E, handler: H): void;
+    /**
+     * Remove all listeners
+     */
+    removeAllListeners(): void;
+    /**
+     * Method of destroying handlers
+     */
+    dispose(): void;
+}
+
+declare class CMap<K = string, V = any> {
+    private _dict;
+    constructor(dict?: CMap<K, V>);
+    get(key: K): V;
+    set(key: K, value: V): this;
+    has(key: K): boolean;
+    delete(key: K): void;
+    clear(): void;
+}
+interface ICacheMap<I = any, B = any> {
+    set: (id: I, bounds: B) => CMap<I, B>;
+    has: (id: I) => boolean;
+    get: (id: I) => B | undefined;
+}
+declare const CACHE_BOX_CHANGE_EVENT_NAME = "change";
+type CacheMapEvents$1 = typeof CACHE_BOX_CHANGE_EVENT_NAME;
+type OnChangeEventListener$1 = (version: number) => void;
+type CacheMapListeners$1 = OnChangeEventListener$1;
+/**
+ * Cache map.
+ * Emits a change event on each mutation.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/utils/cacheMap.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CacheMap<I = string | number, B = any, E = CacheMapEvents$1, L = CacheMapListeners$1> extends EventEmitter<E, L> implements ICacheMap {
+    protected _map: CMap<I, B>;
+    protected _snapshot: CMap<I, B>;
+    protected _version: number;
+    protected _previousVersion: number;
+    protected _lifeCircleTimeout: any;
+    protected _delta: number;
+    get delta(): number;
+    protected _deltaDirection: ScrollDirection;
+    set deltaDirection(v: ScrollDirection);
+    get deltaDirection(): ScrollDirection;
+    private _scrollDirectionCache;
+    private _scrollDirection;
+    get scrollDirection(): ScrollDirection;
+    get version(): number;
+    private _clearScrollDirectionDebounce;
+    constructor();
+    protected changesDetected(): boolean;
+    protected stopLifeCircle(): void;
+    protected nextTick(cb: () => void): any;
+    protected lifeCircle(): void;
+    protected lifeCircleDo(): void;
+    clearScrollDirectionCache(): void;
+    private calcScrollDirection;
+    protected bumpVersion(): void;
+    protected fireChangeIfNeed(): void;
+    set(id: I, bounds: B): CMap<I, B>;
+    has(id: I): boolean;
+    get(id: I): B | undefined;
+    snapshot(): void;
+    dispose(): void;
+}
+
+declare const WIDTH_PROP_NAME = "width";
+declare const HEIGHT_PROP_NAME = "height";
+
+declare const TRACK_BOX_CHANGE_EVENT_NAME = "change";
+interface IMetrics {
+    delta: number;
+    normalizedItemWidth: number;
+    normalizedItemHeight: number;
+    width: number;
+    height: number;
+    dynamicSize: boolean;
+    itemSize: number;
+    itemsFromStartToScrollEnd: number;
+    itemsFromStartToDisplayEnd: number;
+    itemsOnDisplayWeight: number;
+    itemsOnDisplayLength: number;
+    isVertical: boolean;
+    leftHiddenItemsWeight: number;
+    leftItemLength: number;
+    leftItemsWeight: number;
+    renderItems: number;
+    rightItemLength: number;
+    rightItemsWeight: number;
+    scrollSize: number;
+    leftSizeOfAddedItems: number;
+    sizeProperty: typeof HEIGHT_PROP_NAME | typeof WIDTH_PROP_NAME;
+    snap: boolean;
+    snippedPos: number;
+    startIndex: number;
+    startPosition: number;
+    totalItemsToDisplayEndWeight: number;
+    totalLength: number;
+    totalSize: number;
+    typicalItemSize: number;
+}
+interface IRecalculateMetricsOptions<I extends {
+    id: Id;
+}, C extends Array<I>> {
+    bounds: ISize;
+    collection: C;
+    isVertical: boolean;
+    itemSize: number;
+    itemsOffset: number;
+    dynamicSize: boolean;
+    scrollSize: number;
+    snap: boolean;
+    enabledBufferOptimization: boolean;
+    fromItemId?: Id;
+    previousTotalSize: number;
+    crudDetected: boolean;
+    deletedItemsMap: {
+        [index: number]: ISize;
+    };
+}
+interface IGetItemPositionOptions<I extends {
+    id: Id;
+}, C extends Array<I>> extends Omit<IRecalculateMetricsOptions<I, C>, 'previousTotalSize' | 'crudDetected' | 'deletedItemsMap'> {
+}
+interface IUpdateCollectionOptions<I extends {
+    id: Id;
+}, C extends Array<I>> extends Omit<IRecalculateMetricsOptions<I, C>, 'collection' | 'previousTotalSize' | 'crudDetected' | 'deletedItemsMap'> {
+}
+type CacheMapEvents = typeof TRACK_BOX_CHANGE_EVENT_NAME;
+type OnChangeEventListener = (version: number) => void;
+type CacheMapListeners = OnChangeEventListener;
+declare enum ItemDisplayMethods {
+    CREATE = 0,
+    UPDATE = 1,
+    DELETE = 2,
+    NOT_CHANGED = 3
+}
+interface IUpdateCollectionReturns {
+    displayItems: IRenderVirtualListCollection;
+    totalSize: number;
+    delta: number;
+    crudDetected: boolean;
+}
+/**
+ * An object that performs tracking, calculations and caching.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/utils/trackBox.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class TrackBox<C extends BaseVirtualListItemComponent = any> extends CacheMap<Id, ISize & {
+    method?: ItemDisplayMethods;
+}, CacheMapEvents, CacheMapListeners> {
+    protected _tracker: Tracker<C>;
+    protected _items: IRenderVirtualListCollection | null | undefined;
+    set items(v: IRenderVirtualListCollection | null | undefined);
+    protected _displayComponents: Array<ComponentRef<C>> | null | undefined;
+    set displayComponents(v: Array<ComponentRef<C>> | null | undefined);
+    protected _snapedDisplayComponent: ComponentRef<C> | null | undefined;
+    set snapedDisplayComponent(v: ComponentRef<C> | null | undefined);
+    protected _isSnappingMethodAdvanced: boolean;
+    set isSnappingMethodAdvanced(v: boolean);
+    /**
+     * Set the trackBy property
+     */
+    set trackingPropertyName(v: string);
+    constructor(trackingPropertyName: string);
+    set(id: Id, bounds: ISize): CMap<Id, ISize>;
+    protected _previousCollection: Array<{
+        id: Id;
+    }> | null | undefined;
+    protected _deletedItemsMap: {
+        [index: number]: ISize;
+    };
+    protected _crudDetected: boolean;
+    get crudDetected(): boolean;
+    protected fireChangeIfNeed(): void;
+    protected _previousTotalSize: number;
+    protected _scrollDelta: number;
+    get scrollDelta(): number;
+    protected lifeCircle(): void;
+    /**
+     * Scans the collection for deleted items and flushes the deleted item cache.
+     */
+    resetCollection<I extends {
+        id: Id;
+    }, C extends Array<I>>(currentCollection: C | null | undefined, itemSize: number): void;
+    /**
+     * Update the cache of items from the list
+     */
+    protected updateCache<I extends {
+        id: Id;
+    }, C extends Array<I>>(previousCollection: C | null | undefined, currentCollection: C | null | undefined, itemSize: number): void;
+    /**
+     * Finds the position of a collection element by the given Id
+     */
+    getItemPosition<I extends {
+        id: Id;
+    }, C extends Array<I>>(id: Id, stickyMap: IVirtualListStickyMap, options: IGetItemPositionOptions<I, C>): number;
+    /**
+     * Updates the collection of display objects
+     */
+    updateCollection<I extends {
+        id: Id;
+    }, C extends Array<I>>(items: C, stickyMap: IVirtualListStickyMap, options: IUpdateCollectionOptions<I, C>): IUpdateCollectionReturns;
+    /**
+     * Finds the closest element in the collection by scrollSize
+     */
+    getNearestItem<I extends {
+        id: Id;
+    }, C extends Array<I>>(scrollSize: number, items: C, itemSize: number, isVertical: boolean): I | undefined;
+    /**
+     * Calculates the position of an element based on the given scrollSize
+     */
+    protected getElementFromStart<I extends {
+        id: Id;
+    }, C extends Array<I>>(scrollSize: number, collection: C, map: CMap<Id, ISize>, typicalItemSize: number, isVertical: boolean): I | undefined;
+    /**
+     * Calculates the entry into the overscroll area and returns the number of overscroll elements
+     */
+    protected getElementNumToEnd<I extends {
+        id: Id;
+    }, C extends Array<I>>(i: number, collection: C, map: CMap<Id, ISize>, typicalItemSize: number, size: number, isVertical: boolean, indexOffset?: number): {
+        num: number;
+        offset: number;
+    };
+    /**
+     * Calculates list metrics
+     */
+    protected recalculateMetrics<I extends {
+        id: Id;
+    }, C extends Array<I>>(options: IRecalculateMetricsOptions<I, C>): IMetrics;
+    clearDeltaDirection(): void;
+    clearDelta(clearDirectionDetector?: boolean): void;
+    changes(): void;
+    protected generateDisplayCollection<I extends {
+        id: Id;
+    }, C extends Array<I>>(items: C, stickyMap: IVirtualListStickyMap, metrics: IMetrics): IRenderVirtualListCollection;
+    /**
+     * tracking by propName
+     */
+    track(): void;
+    setDisplayObjectIndexMapById(v: {
+        [id: number]: number;
+    }): void;
+    untrackComponentByIdProperty(component?: C | undefined): void;
+    getItemBounds(id: Id): ISize | undefined;
+    protected cacheElements(): void;
+    dispose(): void;
+}
+
+/**
+ * Virtual list component.
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/20.x/projects/ng-virtual-list/src/lib/ng-virtual-list.component.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class NgVirtualListComponent implements AfterViewInit, OnInit, OnDestroy {
+    protected static __nextId: number;
+    protected _id: number;
+    /**
+     * Readonly. Returns the unique identifier of the component.
+     */
+    get id(): number;
+    protected _listContainerRef: ViewContainerRef | undefined;
+    protected _snapContainerRef: ViewContainerRef | undefined;
+    protected _snappedContainer: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    protected _container: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    protected _list: _angular_core.Signal<ElementRef<HTMLUListElement> | undefined>;
+    /**
+     * Fires when the list has been scrolled.
+     */
+    onScroll: _angular_core.OutputEmitterRef<IScrollEvent>;
+    /**
+     * Fires when the list has completed scrolling.
+     */
+    onScrollEnd: _angular_core.OutputEmitterRef<IScrollEvent>;
+    protected _itemsOptions: any;
+    /**
+     * Collection of list items.
+     */
+    items: _angular_core.InputSignal<IVirtualListCollection<Object>>;
+    /**
+     * Determines whether elements will snap. Default value is "true".
+     */
+    snap: _angular_core.InputSignal<boolean>;
+    /**
+     * Experimental!
+     * Enables buffer optimization.
+     * Can only be used if items in the collection are not added or updated. Otherwise, artifacts in the form of twitching of the scroll area are possible.
+     * Works only if the property dynamic = true
+     */
+    enabledBufferOptimization: _angular_core.InputSignal<boolean>;
+    /**
+     * Rendering element template.
+     */
+    itemRenderer: _angular_core.InputSignal<TemplateRef<any>>;
+    protected _itemRenderer: WritableSignal<TemplateRef<any> | undefined>;
+    /**
+     * Dictionary zIndex by id of the list element. If the value is not set or equal to 0,
+     * then a simple element is displayed, if the value is greater than 0, then the sticky position mode is enabled for the element.
+     */
+    stickyMap: _angular_core.InputSignal<IVirtualListStickyMap>;
+    protected _itemSizeOptions: any;
+    /**
+     * If direction = 'vertical', then the height of a typical element. If direction = 'horizontal', then the width of a typical element.
+     * Ignored if the dynamicSize property is true.
+     */
+    itemSize: _angular_core.InputSignal<number>;
+    /**
+     * If true then the items in the list can have different sizes and the itemSize property is ignored.
+     * If false then the items in the list have a fixed size specified by the itemSize property. The default value is false.
+     */
+    dynamicSize: _angular_core.InputSignal<boolean>;
+    /**
+     * Determines the direction in which elements are placed. Default value is "vertical".
+     */
+    direction: _angular_core.InputSignal<Direction>;
+    /**
+     * Number of elements outside the scope of visibility. Default value is 2.
+     */
+    itemsOffset: _angular_core.InputSignal<number>;
+    /**
+     * Snapping method.
+     * 'default' - Normal group rendering.
+     * 'advanced' - The group is rendered on a transparent background. List items below the group are not rendered.
+     */
+    snappingMethod: _angular_core.InputSignal<SnappingMethod>;
+    protected _isSnappingMethodAdvanced: boolean;
+    get isSnappingMethodAdvanced(): boolean;
+    protected _isVertical: boolean;
+    protected _displayComponents: Array<ComponentRef<BaseVirtualListItemComponent>>;
+    protected _snapedDisplayComponent: ComponentRef<BaseVirtualListItemComponent> | undefined;
+    protected _bounds: WritableSignal<ISize | null>;
+    protected _scrollSize: WritableSignal<number>;
+    protected _resizeObserver: ResizeObserver | null;
+    protected _resizeSnappedComponentHandler: () => void;
+    protected _resizeSnappedObserver: ResizeObserver | null;
+    protected _componentsResizeObserver: ResizeObserver;
+    protected _onResizeHandler: () => void;
+    protected _onScrollHandler: (e?: Event) => void;
+    protected _elementRef: ElementRef<any>;
+    protected _initialized: WritableSignal<boolean>;
+    readonly $initialized: Observable<boolean>;
+    /**
+     * The name of the property by which tracking is performed
+     */
+    trackBy: _angular_core.InputSignal<string>;
+    /**
+     * Base class of the element component
+     */
+    protected _itemComponentClass: Component$1<BaseVirtualListItemComponent>;
+    /**
+     * Base class trackBox
+     */
+    protected _trackBoxClass: Component$1<TrackBox>;
+    /**
+     * Dictionary of element sizes by their id
+     */
+    protected _trackBox: TrackBox;
+    protected _onTrackBoxChangeHandler: (v: number) => void;
+    protected _cacheVersion: WritableSignal<number>;
+    constructor();
+    protected setupRenderer(): void;
+    protected onInit(): void;
+    protected listenCacheChangesIfNeed(value: boolean): void;
+    protected getIsSnappingMethodAdvanced(m?: SnappingMethod): boolean;
+    protected getIsVertical(d?: Direction): boolean;
+    protected createDisplayComponentsIfNeed(displayItems: IRenderVirtualListCollection | null): void;
+    protected updateRegularRenderer(): void;
+    protected resetRenderers(itemRenderer?: TemplateRef<HTMLElement>): void;
+    /**
+     * Tracking by id
+     */
+    protected tracking(): void;
+    protected resetBoundsSize(isVertical: boolean, totalSize: number): void;
+    /**
+     * Returns the bounds of an element with a given id
+     */
+    getItemBounds(id: Id): ISize | undefined;
+    /**
+     * The method scrolls the list to the element with the given id and returns the value of the scrolled area.
+     * Behavior accepts the values ​​"auto", "instant" and "smooth".
+     */
+    scrollTo(id: Id, behavior?: ScrollBehavior): void;
+    protected _scrollToRepeatExecutionTimeout: number | undefined;
+    protected clearScrollToRepeatExecutionTimeout(): void;
+    protected scrollToExecutor(id: Id, behavior: ScrollBehavior, iteration?: number, isLastIteration?: boolean): void;
+    /**
+     * Scrolls the scroll area to the desired element with the specified ID.
+     */
+    scrollToEnd(behavior?: ScrollBehavior): void;
+    protected _onContainerScrollHandler: (e: Event) => void;
+    protected _onContainerScrollEndHandler: (e: Event) => void;
+    protected afterViewInit(): void;
+    protected dispose(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgVirtualListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgVirtualListComponent, "ng-virtual-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "snap": { "alias": "snap"; "required": false; "isSignal": true; }; "enabledBufferOptimization": { "alias": "enabledBufferOptimization"; "required": false; "isSignal": true; }; "itemRenderer": { "alias": "itemRenderer"; "required": true; "isSignal": true; }; "stickyMap": { "alias": "stickyMap"; "required": false; "isSignal": true; }; "itemSize": { "alias": "itemSize"; "required": false; "isSignal": true; }; "dynamicSize": { "alias": "dynamicSize"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "itemsOffset": { "alias": "itemsOffset"; "required": false; "isSignal": true; }; "snappingMethod": { "alias": "snappingMethod"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; }, { "onScroll": "onScroll"; "onScrollEnd": "onScrollEnd"; }, never, never, true, never>;
+}
+
+export { BaseVirtualListItemComponent, Directions, NgVirtualListComponent, NgVirtualListItemComponent, SnappingMethods };
+export type { Component$1, Direction, IRect, IScrollEvent, ISize, IVirtualListCollection, IVirtualListItem, IVirtualListStickyMap, Id, ScrollDirection, SnappingMethod };