@rx-angular/template/experimental/virtual-scrolling/lib/model.d.ts

**Fully** Reactive Component Template Rendering in Angular. @rx-angular/template aims to be a reflection of Angular's built in renderings just reactive.

import { ElementRef, EmbeddedViewRef, NgIterable, TemplateRef, TrackByFunction, ViewContainerRef } from '@angular/core';
import { RxDefaultListViewContext } from '@rx-angular/cdk/template';
import { Observable, Subject } from 'rxjs';
import * as i0 from "@angular/core";
type CreateViewContext<Implicit, Context, ComputedContext> = (value: Implicit, computedContext: ComputedContext) => Context;
type UpdateViewContext<Implicit, Context, ComputedContext> = (value: Implicit, view: EmbeddedViewRef<Context>, computedContext?: ComputedContext) => void;
export interface TemplateSettings<Implicit, Context, ComputedContext> {
    viewContainerRef: ViewContainerRef;
    templateRef: TemplateRef<Context>;
    createViewContext: CreateViewContext<Implicit, Context, ComputedContext>;
    updateViewContext: UpdateViewContext<Implicit, Context, ComputedContext>;
    templateCacheSize: number;
}
export interface ListRange {
    start: number;
    end: number;
}
/**
 * @Directive RxVirtualScrollStrategy
 *
 * @description
 * Abstract implementation for the actual implementations of the ScrollStrategies
 * being consumed by `*rxVirtualFor` and `rx-virtual-scroll-viewport`.
 *
 * This is one of the core parts for the virtual scrolling implementation. It has
 * to determine the `ListRange` being rendered to the DOM as well as managing
 * the layouting task for the `*rxVirtualFor` directive.
 *
 * @docsCategory RxVirtualFor
 * @docsPage RxVirtualFor
 * @publicApi
 */
export declare abstract class RxVirtualScrollStrategy<T, U extends NgIterable<T> = NgIterable<T>> {
    /** Emits when the index of the first element visible in the viewport changes. */
    /** @internal */
    abstract scrolledIndex$: Observable<number>;
    /** @internal */
    abstract renderedRange$: Observable<ListRange>;
    /** @internal */
    abstract contentSize$: Observable<number>;
    /** @internal */
    get isStable(): Observable<boolean>;
    /**
     * @description
     *
     * Emits whenever an update to a single view was rendered
     */
    readonly viewRenderCallback: Subject<{
        view: EmbeddedViewRef<RxVirtualForViewContext<T, U>>;
        item: T;
        index: number;
    }>;
    /** @internal */
    private nodeIndex?;
    /** @internal */
    protected getElement(view: EmbeddedViewRef<RxVirtualForViewContext<T, U>>): HTMLElement;
    /**
     * Attaches this scroll strategy to a viewport.
     * @param viewport The viewport to attach this strategy to.
     * @param viewRepeater The viewRepeater attached to the viewport.
     */
    abstract attach(viewport: RxVirtualScrollViewport, viewRepeater: RxVirtualViewRepeater<any>): void;
    /** Detaches this scroll strategy from the currently attached viewport. */
    abstract detach(): void;
    /**
     * Scroll to the offset for the given index.
     * @param index The index of the element to scroll to.
     * @param behavior The ScrollBehavior to use when scrolling.
     */
    abstract scrollToIndex(index: number, behavior?: ScrollBehavior): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RxVirtualScrollStrategy<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RxVirtualScrollStrategy<any, any>, never, never, {}, {}, never, never, true, never>;
}
/** @internal */
export declare abstract class RxVirtualScrollViewport {
    abstract elementScrolled$: Observable<void>;
    abstract containerRect$: Observable<{
        height: number;
        width: number;
    }>;
    abstract getScrollTop(): number;
    abstract scrollTo(scrollTo: number, behavior?: ScrollBehavior): void;
    abstract getScrollElement(): HTMLElement;
    abstract measureOffset(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<RxVirtualScrollViewport, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RxVirtualScrollViewport, never, never, {}, {}, never, never, true, never>;
}
/** @internal */
export declare abstract class RxVirtualViewRepeater<T, U extends NgIterable<T> = NgIterable<T>> {
    abstract values$: Observable<U | null | undefined>;
    abstract viewsRendered$: Observable<EmbeddedViewRef<RxVirtualForViewContext<T, U>>[]>;
    abstract viewRendered$: Observable<{
        view: EmbeddedViewRef<RxVirtualForViewContext<T, U>>;
        index: number;
        item: T;
    }>;
    abstract viewContainer: ViewContainerRef;
    abstract renderingStart$: Observable<Set<number>>;
    _trackBy: TrackByFunction<T> | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<RxVirtualViewRepeater<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RxVirtualViewRepeater<any, any>, never, never, {}, {}, never, never, true, never>;
}
/** @internal */
export declare class RxVirtualForViewContext<T, U extends NgIterable<T> = NgIterable<T>, C extends {
    count: number;
    index: number;
} = {
    count: number;
    index: number;
}, K = keyof T> extends RxDefaultListViewContext<T, U, K> {
    rxVirtualForOf: U;
    constructor(item: T, rxVirtualForOf: U, customProps?: C);
}
export declare abstract class RxVirtualScrollElement {
    abstract elementScrolled$: Observable<void>;
    abstract getElementRef(): ElementRef<HTMLElement>;
    abstract measureOffset(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<RxVirtualScrollElement, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RxVirtualScrollElement, never, never, {}, {}, never, never, true, never>;
}
export {};