557 lines
21 KiB
TypeScript
557 lines
21 KiB
TypeScript
import type { ComponentProps } from '@fluentui/react-utilities';
|
|
import type { ComponentState } from '@fluentui/react-utilities';
|
|
import * as React_2 from 'react';
|
|
import type { Slot } from '@fluentui/react-utilities';
|
|
import type { SlotClassNames } from '@fluentui/react-utilities';
|
|
|
|
/**
|
|
* Some props are optional on static virtualizer, but required for dynamic.
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type DynamicVirtualizerContextProps = Required<VirtualizerContextProps>;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare interface IndexedResizeCallbackElement {
|
|
handleResize: () => void;
|
|
}
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const renderVirtualizer_unstable: (state: VirtualizerState) => React_2.ReactElement;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const renderVirtualizerScrollView_unstable: (state: VirtualizerScrollViewState) => React_2.ReactElement;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const renderVirtualizerScrollViewDynamic_unstable: (state: VirtualizerScrollViewDynamicState) => React_2.ReactElement;
|
|
|
|
/**
|
|
* Additional direct Ref prevents reading old resize entry data
|
|
* Backwards compatible with ResizeObserverCallback if preferred
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare interface ResizeCallbackWithRef {
|
|
(entries: ResizeObserverEntry[], observer: ResizeObserver, scrollRef?: React_2.MutableRefObject<HTMLElement | null>): void;
|
|
}
|
|
|
|
export declare type ScrollToInterface = {
|
|
scrollTo: (index: number, behavior?: ScrollBehavior, callback?: (index: number) => void) => void;
|
|
virtualizerLength: React_2.RefObject<number>;
|
|
currentIndex: React_2.RefObject<number> | undefined;
|
|
};
|
|
|
|
export declare const scrollToItemDynamic: (params: ScrollToItemDynamicParams) => void;
|
|
|
|
export declare type ScrollToItemDynamicParams = {
|
|
index: number;
|
|
itemSizes: React_2.RefObject<number[]>;
|
|
totalSize: number;
|
|
scrollViewRef: React_2.RefObject<HTMLDivElement>;
|
|
axis?: 'horizontal' | 'vertical';
|
|
reversed?: boolean;
|
|
behavior?: ScrollBehavior;
|
|
};
|
|
|
|
export declare const scrollToItemStatic: (params: ScrollToItemStaticParams) => void;
|
|
|
|
export declare type ScrollToItemStaticParams = {
|
|
index: number;
|
|
itemSize: number;
|
|
totalItems: number;
|
|
scrollViewRef: React_2.RefObject<HTMLDivElement>;
|
|
axis?: 'horizontal' | 'vertical';
|
|
reversed?: boolean;
|
|
behavior?: ScrollBehavior;
|
|
};
|
|
|
|
/**
|
|
* React hook that measures virtualized space dynamically to ensure optimized virtualization length.
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const useDynamicVirtualizerMeasure: <TElement extends HTMLElement>(virtualizerProps: VirtualizerMeasureDynamicProps) => {
|
|
virtualizerLength: number;
|
|
bufferItems: number;
|
|
bufferSize: number;
|
|
scrollRef: (instance: TElement | null) => void;
|
|
containerSizeRef: React_2.RefObject<number>;
|
|
updateScrollPosition: (scrollPosition: number) => void;
|
|
};
|
|
|
|
/**
|
|
* React hook that allows easy usage of the browser API IntersectionObserver within React
|
|
* @param callback - A function called when the percentage of the target element is visible crosses a threshold.
|
|
* @param options - An optional object which customizes the observer. If options isn't specified, the observer uses the
|
|
* document's viewport as the root, with no margin, and a 0% threshold (meaning that even a one-pixel change is
|
|
* enough to trigger a callback).
|
|
* @returns An array containing a callback to update the list of Elements the observer should listen to, a callback to
|
|
* update the init options of the IntersectionObserver and a ref to the IntersectionObserver instance itself.
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const useIntersectionObserver: (callback: IntersectionObserverCallback, options?: IntersectionObserverInit) => {
|
|
setObserverList: React_2.Dispatch<React_2.SetStateAction<Element[] | undefined>>;
|
|
setObserverInit: (newInit: IntersectionObserverInit | undefined) => void;
|
|
observer: React_2.MutableRefObject<IntersectionObserver | undefined>;
|
|
};
|
|
|
|
/**
|
|
* Provides a way of automating size in the virtualizer
|
|
* Returns
|
|
* `width` - element width ref (0 by default),
|
|
* `height` - element height ref (0 by default),
|
|
* `measureElementRef` - a ref function to be passed as `ref` to the element you want to measure
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare function useMeasureList<TElement extends HTMLElement & IndexedResizeCallbackElement = HTMLElement & IndexedResizeCallbackElement>(currentIndex: number, refLength: number, totalLength: number, defaultItemSize: number): {
|
|
widthArray: React_2.MutableRefObject<number[]>;
|
|
heightArray: React_2.MutableRefObject<number[]>;
|
|
createIndexedRef: (index: number) => (el: TElement | null) => void;
|
|
refArray: React_2.MutableRefObject<Array<TElement | undefined | null>>;
|
|
sizeUpdateCount: number;
|
|
};
|
|
|
|
/**
|
|
* useResizeObserverRef_unstable simplifies resize observer connection and ensures debounce/cleanup
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const useResizeObserverRef_unstable: (resizeCallback: ResizeCallbackWithRef) => ((instance: HTMLElement | HTMLDivElement | null) => void);
|
|
|
|
/**
|
|
* React hook that measures virtualized space based on a static size to ensure optimized virtualization length.
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const useStaticVirtualizerMeasure: <TElement extends HTMLElement>(virtualizerProps: VirtualizerMeasureProps) => {
|
|
virtualizerLength: number;
|
|
bufferItems: number;
|
|
bufferSize: number;
|
|
scrollRef: (instance: TElement | null) => void;
|
|
containerSizeRef: React_2.MutableRefObject<number>;
|
|
};
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare function useVirtualizer_unstable(props: VirtualizerProps): VirtualizerState;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const useVirtualizerContext_unstable: () => VirtualizerContextProps;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare function useVirtualizerScrollView_unstable(props: VirtualizerScrollViewProps): VirtualizerScrollViewState;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare function useVirtualizerScrollViewDynamic_unstable(props: VirtualizerScrollViewDynamicProps): VirtualizerScrollViewDynamicState;
|
|
|
|
/**
|
|
* Apply styling to the Virtualizer states
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const useVirtualizerScrollViewDynamicStyles_unstable: (state: VirtualizerScrollViewDynamicState) => VirtualizerScrollViewDynamicState;
|
|
|
|
/**
|
|
* Apply styling to the Virtualizer states
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const useVirtualizerScrollViewStyles_unstable: (state: VirtualizerScrollViewState) => VirtualizerScrollViewState;
|
|
|
|
/**
|
|
* Apply styling to the Virtualizer states
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const useVirtualizerStyles_unstable: (state: VirtualizerState) => VirtualizerState;
|
|
|
|
/**
|
|
* Virtualizer pseudo-component, this functional wrapper
|
|
* provides a simple interface for reducing the total number
|
|
* of elements rendered at one time in large lists.
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const Virtualizer: React_2.FC<VirtualizerProps>;
|
|
|
|
/**
|
|
* The main child render method of Virtualization
|
|
* isScrolling will only be enabled when enableScrollLoad is set to true.
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerChildRenderFunction = (index: number, isScrolling: boolean) => React_2.ReactNode;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const virtualizerClassNames: SlotClassNames<VirtualizerSlots>;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
declare type VirtualizerConfigProps = {
|
|
/**
|
|
* Child render function.
|
|
* Iteratively called to return current virtualizer DOM children.
|
|
* Will act as a row or column indexer depending on Virtualizer settings.
|
|
* Can be used dynamically.
|
|
*/
|
|
children: VirtualizerChildRenderFunction;
|
|
/**
|
|
* Default cell size to use if no custom callback provided.
|
|
* If implementing `getItemSize` this should be the initial and ideally minimum cell size.
|
|
*/
|
|
itemSize: number;
|
|
/**
|
|
* The total number of items to be virtualized.
|
|
*/
|
|
numItems: number;
|
|
/**
|
|
* Number of children to render in the DOM during virtualization.
|
|
* Constraints:
|
|
* - Large enough that the items rendered in DOM cover the viewport
|
|
* and intersection observer buffers (buffersize) at both ends.
|
|
*/
|
|
virtualizerLength: number;
|
|
/**
|
|
* Defaults to 1/4th (or 1/3rd for dynamic items) of virtualizerLength.
|
|
* RECOMMEND: Override this with a consistent value if using a dynamic virtualizer.
|
|
*
|
|
* Controls the number of elements rendered before the current index entering the virtualized viewport.
|
|
* Constraints:
|
|
* - Large enough to cover bufferSize (prevents buffers intersecting into the viewport during rest state).
|
|
* - Small enough that the virtualizer only renders a few items outside of view.
|
|
*/
|
|
bufferItems?: number;
|
|
/**
|
|
* Defaults to half of bufferItems * itemSize size (in pixels).
|
|
* RECOMMEND: Override this with a consistent minimum item size value if using a dynamic virtualizer.
|
|
* The length (in pixels) before the end/start DOM index where the virtualizer recalculation will be triggered.
|
|
* Increasing this reduces whitespace on ultra-fast scroll, as additional elements
|
|
* are buffered to appear while virtualization recalculates.
|
|
* Constraints:
|
|
* - At least 1px - although this will only trigger the recalculation after bookends (whitespace) enter viewport.
|
|
* - BufferSize must be smaller than bufferItems pixel size, as it prevents bookends entering viewport at rest.
|
|
*/
|
|
bufferSize?: number;
|
|
/**
|
|
* Enables users to override the intersectionObserverRoot.
|
|
* We recommend passing this in for accurate distance assessment in IO
|
|
*/
|
|
scrollViewRef?: React_2.MutableRefObject<HTMLElement | null>;
|
|
/**
|
|
* The scroll direction
|
|
* @default vertical
|
|
*/
|
|
axis?: 'vertical' | 'horizontal';
|
|
/**
|
|
* Tells the virtualizer to measure in the reverse direction (for column-reverse order etc.)
|
|
* This value should be flipped in RTL implementation (TBD whether automate RTL).
|
|
*/
|
|
reversed?: boolean;
|
|
/**
|
|
* Enables the isScrolling property in the child render function
|
|
* Default: false - to prevent nessecary render function calls
|
|
*/
|
|
enableScrollLoad?: boolean;
|
|
/**
|
|
* Callback for acquiring size of individual items
|
|
* @param index - the index of the requested size's child
|
|
*/
|
|
getItemSize?: (index: number) => number;
|
|
/**
|
|
* Virtualizer context can be passed as a prop for extended class use
|
|
*/
|
|
virtualizerContext?: VirtualizerContextProps;
|
|
/**
|
|
* Callback for notifying when a flagged index has been rendered
|
|
*/
|
|
onRenderedFlaggedIndex?: (index: number) => void;
|
|
flaggedIndex?: React_2.MutableRefObject<number | null>;
|
|
/**
|
|
* Imperative ref contains our scrollTo index functionality for user control.
|
|
*/
|
|
imperativeVirtualizerRef?: React_2.RefObject<VirtualizerDataRef | null>;
|
|
/**
|
|
* A ref that provides the size of container (vertical - height, horizontal - width), set by a resize observer.
|
|
* Virtualizer Measure hooks provide a suitable reference.
|
|
*/
|
|
containerSizeRef: React_2.RefObject<number>;
|
|
/**
|
|
* A callback that enables updating scroll position for calculating required dynamic lengths,
|
|
* this should be passed in from useDynamicVirtualizerMeasure
|
|
*/
|
|
updateScrollPosition?: (position: number) => void;
|
|
/**
|
|
* Spacing between rendered children for calculation, should match the container's gap CSS value.
|
|
*/
|
|
gap?: number;
|
|
};
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
declare type VirtualizerConfigState = {
|
|
/**
|
|
* The current virtualized array of children to show in the DOM.
|
|
*/
|
|
virtualizedChildren: React_2.ReactNode[];
|
|
/**
|
|
* The current start index for the virtualizer, all previous index's will be removed from DOM.
|
|
*/
|
|
virtualizerStartIndex: number;
|
|
/**
|
|
* Current buffer height required at beginning of array.
|
|
*/
|
|
afterBufferHeight: number;
|
|
/**
|
|
* Current buffer height required at end of array.
|
|
*/
|
|
beforeBufferHeight: number;
|
|
/**
|
|
* The total current height of the scrollView/child content.
|
|
*/
|
|
totalVirtualizerHeight: number;
|
|
/**
|
|
* The scroll direction
|
|
* @default vertical
|
|
*/
|
|
axis?: 'vertical' | 'horizontal';
|
|
/**
|
|
* Tells the virtualizer to measure in the reverse direction (for column-reverse order etc.)
|
|
*/
|
|
reversed?: boolean;
|
|
/**
|
|
* Enables the isScrolling property in the child render function
|
|
* Default: false - to prevent nessecary render function calls
|
|
*/
|
|
enableScrollLoad?: boolean;
|
|
/**
|
|
* Pixel size of intersection observers and how much they 'cross over' into the bufferItems index.
|
|
* Minimum 1px.
|
|
*/
|
|
bufferSize: number;
|
|
/**
|
|
* Ref for access to internal size knowledge, can be used to measure updates
|
|
*/
|
|
childSizes: React_2.MutableRefObject<number[]>;
|
|
/**
|
|
* Ref for access to internal progressive size knowledge, can be used to measure updates
|
|
*/
|
|
childProgressiveSizes: React_2.MutableRefObject<number[]>;
|
|
};
|
|
|
|
/**
|
|
* {@docCategory Virtualizer}
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerContextProps = {
|
|
contextIndex: number;
|
|
setContextIndex: (index: number) => void;
|
|
childProgressiveSizes?: React_2.MutableRefObject<number[]>;
|
|
};
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const VirtualizerContextProvider: React_2.Provider<VirtualizerContextProps>;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerDataRef = {
|
|
progressiveSizes: React_2.RefObject<number[]>;
|
|
nodeSizes: React_2.RefObject<number[]>;
|
|
setFlaggedIndex: (index: number | null) => void;
|
|
currentIndex: React_2.RefObject<number>;
|
|
};
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerMeasureDynamicProps = {
|
|
defaultItemSize: number;
|
|
virtualizerContext: DynamicVirtualizerContextProps;
|
|
numItems: number;
|
|
getItemSize: (index: number) => number;
|
|
direction?: 'vertical' | 'horizontal';
|
|
/**
|
|
* Override recommended number of buffer items
|
|
*/
|
|
bufferItems?: number;
|
|
/**
|
|
* Override recommended buffer size (px)
|
|
*/
|
|
bufferSize?: number;
|
|
};
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerMeasureProps = {
|
|
defaultItemSize: number;
|
|
direction?: 'vertical' | 'horizontal';
|
|
/**
|
|
* Override recommended number of buffer items
|
|
*/
|
|
bufferItems?: number;
|
|
/**
|
|
* Override recommended buffer size (px)
|
|
*/
|
|
bufferSize?: number;
|
|
};
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerProps = ComponentProps<Partial<VirtualizerSlots>> & VirtualizerConfigProps;
|
|
|
|
/**
|
|
* Virtualizer ScrollView
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const VirtualizerScrollView: React_2.FC<VirtualizerScrollViewProps>;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const virtualizerScrollViewClassNames: SlotClassNames<VirtualizerScrollViewSlots>;
|
|
|
|
/**
|
|
* Virtualizer ScrollView
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const VirtualizerScrollViewDynamic: React_2.FC<VirtualizerScrollViewDynamicProps>;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare const virtualizerScrollViewDynamicClassNames: SlotClassNames<VirtualizerScrollViewDynamicSlots>;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerScrollViewDynamicProps = ComponentProps<Partial<VirtualizerScrollViewDynamicSlots>> & Partial<Omit<VirtualizerConfigProps, 'itemSize' | 'numItems' | 'getItemSize' | 'children' | 'flagIndex' | 'virtualizerContext'>> & {
|
|
/**
|
|
* Set as the minimum item size.
|
|
* Axis: 'vertical' = Height
|
|
* Axis: 'horizontal' = Width
|
|
*/
|
|
itemSize: number;
|
|
/**
|
|
* Callback for acquiring size of individual items
|
|
* @param index - the index of the requested size's child
|
|
* If undefined, Virtualizer will auto-measure by default (performance tradeoff)
|
|
*/
|
|
getItemSize?: (index: number) => number;
|
|
/**
|
|
* The total number of items to be virtualized.
|
|
*/
|
|
numItems: number;
|
|
/**
|
|
* Child render function.
|
|
* Iteratively called to return current virtualizer DOM children.
|
|
* Will act as a row or column indexer depending on Virtualizer settings.
|
|
*/
|
|
children: VirtualizerChildRenderFunction;
|
|
/**
|
|
* Imperative ref contains our scrollTo index functionality for user control.
|
|
*/
|
|
imperativeRef?: React_2.RefObject<ScrollToInterface | null>;
|
|
/**
|
|
* Imperative ref contains our scrollTo index functionality for user control.
|
|
*/
|
|
enablePagination?: boolean;
|
|
/**
|
|
* Enables override of dynamic virtualizer context if required.
|
|
*/
|
|
virtualizerContext?: DynamicVirtualizerContextProps;
|
|
};
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerScrollViewDynamicSlots = VirtualizerScrollViewSlots;
|
|
|
|
export declare type VirtualizerScrollViewDynamicState = ComponentState<VirtualizerScrollViewDynamicSlots> & VirtualizerConfigState;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerScrollViewProps = ComponentProps<Partial<VirtualizerScrollViewSlots>> & Partial<Omit<VirtualizerConfigProps, 'itemSize' | 'numItems' | 'getItemSize' | 'children' | 'flagIndex' | 'imperativeVirtualizerRef'>> & {
|
|
/**
|
|
* Virtualizer item size in pixels - static.
|
|
* Axis: 'vertical' = Height
|
|
* Axis: 'horizontal' = Width
|
|
*/
|
|
itemSize: number;
|
|
/**
|
|
* The total number of items to be virtualized.
|
|
*/
|
|
numItems: number;
|
|
/**
|
|
* Child render function.
|
|
* Iteratively called to return current virtualizer DOM children.
|
|
* Will act as a row or column indexer depending on Virtualizer settings.
|
|
*/
|
|
children: VirtualizerChildRenderFunction;
|
|
/**
|
|
* Imperative ref contains our scrollTo index functionality for user control.
|
|
*/
|
|
imperativeRef?: React_2.RefObject<ScrollToInterface | null>;
|
|
/**
|
|
* Imperative ref contains our scrollTo index functionality for user control.
|
|
*/
|
|
enablePagination?: boolean;
|
|
};
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerScrollViewSlots = VirtualizerSlots & {
|
|
/**
|
|
* The root container that provides embedded scrolling.
|
|
*/
|
|
container: NonNullable<Slot<'div'>>;
|
|
};
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerScrollViewState = ComponentState<VirtualizerScrollViewSlots> & VirtualizerConfigState;
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerSlots = {
|
|
/**
|
|
* The intersection observed 'before' element will detect when scrolling towards the beginning.
|
|
*/
|
|
before: NonNullable<Slot<'div', 'td'>>;
|
|
/**
|
|
* A block place holding whitespace at the beginning of current DOM children.
|
|
*/
|
|
beforeContainer: NonNullable<Slot<'div', 'tr'>>;
|
|
/**
|
|
* The intersection observed 'after' element will detect when scrolling towards the end.
|
|
*/
|
|
after: NonNullable<Slot<'div', 'td'>>;
|
|
/**
|
|
* A block place holding whitespace after the end of current DOM children.
|
|
*/
|
|
afterContainer: NonNullable<Slot<'div', 'tr'>>;
|
|
};
|
|
|
|
/**
|
|
* @deprecated migrated to \@fluentui\-contrib/react\-virtualizer for stable release.
|
|
*/
|
|
export declare type VirtualizerState = ComponentState<VirtualizerSlots> & VirtualizerConfigState;
|
|
|
|
export { }
|