@ringcentral/juno 2.40.1 → 2.41.0

package/components/Virtuoso/react-virtuoso/comparators.d.ts

@@ -1,3 +1,3 @@
 import { ListRange } from './interfaces';
-export declare function tupleComparator(prev: [any, any] | undefined, current: [any, any]): boolean;
+export declare function tupleComparator<T1, T2>(prev: [T1, T2] | undefined, current: [T1, T2]): boolean;
 export declare function rangeComparator(prev: ListRange | undefined, next: ListRange): boolean;

package/components/Virtuoso/react-virtuoso/comparators.js

@@ -5,8 +5,6 @@ function tupleComparator(prev, current) {
 }
 exports.tupleComparator = tupleComparator;
 function rangeComparator(prev, next) {
-    return !!(prev &&
-        prev.startIndex === next.startIndex &&
-        prev.endIndex === next.endIndex);
+    return !!(prev && prev.startIndex === next.startIndex && prev.endIndex === next.endIndex);
 }
 exports.rangeComparator = rangeComparator;

package/components/Virtuoso/react-virtuoso/component-interfaces/TableVirtuoso.d.ts

@@ -0,0 +1,194 @@
+import type { ComputeItemKey, FixedHeaderContent, FixedFooterContent, FlatIndexLocationWithAlign, FlatScrollIntoViewLocation, FollowOutput, ItemContent, ListItem, ListRange, ScrollSeekConfiguration, SizeFunction, TableComponents, StateSnapshot, StateCallback } from '../interfaces';
+import type { VirtuosoProps } from './Virtuoso';
+export interface TableVirtuosoProps<D, C> extends Omit<VirtuosoProps<D, C>, 'components' | 'headerFooterTag' | 'topItemCount'> {
+    /**
+     * Use the `components` property for advanced customization of the elements rendered by the table.
+     */
+    components?: TableComponents<D, C>;
+    /**
+     * Set the contents of the table header.
+     */
+    fixedHeaderContent?: FixedHeaderContent;
+    /**
+     * Set the contents of the table footer.
+     */
+    fixedFooterContent?: FixedFooterContent;
+    /**
+     * The total amount of items to be rendered.
+     */
+    totalCount?: number;
+    /**
+     * The data items to be rendered. If data is set, the total count will be inferred from the length of the array.
+     */
+    data?: readonly D[];
+    /**
+     * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+     * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+     * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+     * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+     */
+    overscan?: number | {
+        main: number;
+        reverse: number;
+    };
+    /**
+     * Set the increaseViewportBy property to artificially increase the viewport size, causing items to be rendered before outside of the viewport.
+     * The property causes the component to render more items than the necessary, but can help with slow loading content.
+     * Using `{ top?: number, bottom?: number }` lets you set the increase for each end separately.
+     */
+    increaseViewportBy?: number | {
+        top: number;
+        bottom: number;
+    };
+    /**
+     * Set to a value between 0 and totalCount - 1 to make the list start scrolled to that item.
+     */
+    initialTopMostItemIndex?: number;
+    /**
+     * Set this value to offset the initial location of the list.
+     * Warning: using this property will still run a render cycle at the scrollTop: 0 list window.
+     * If possible, avoid using it and stick to `initialTopMostItemIndex` instead.
+     */
+    initialScrollTop?: number;
+    /**
+     * Use for server-side rendering - if set, the list will render the specified amount of items
+     * regardless of the container / item size.
+     */
+    initialItemCount?: number;
+    /**
+     * Set the callback to specify the contents of the item.
+     */
+    itemContent?: ItemContent<D, C>;
+    /**
+     * If specified, the component will use the function to generate the `key` property for each list item.
+     */
+    computeItemKey?: ComputeItemKey<D, C>;
+    /**
+     * By default, the component assumes the default item height from the first rendered item (rendering it as a "probe").
+     *
+     * If the first item turns out to be an outlier (very short or tall), the rest of the rendering will be slower,
+     * as multiple passes of rendering should happen for the list to fill the viewport.
+     *
+     * Setting `defaultItemHeight` causes the component to skip the "probe" rendering and use the property
+     * value as default height instead.
+     */
+    defaultItemHeight?: number;
+    /**
+     * Allows customizing the height/width calculation of `Item` elements.
+     *
+     * The default implementation reads `el.getBoundingClientRect().height` and `el.getBoundingClientRect().width`.
+     */
+    itemSize?: SizeFunction;
+    /**
+     * Can be used to improve performance if the rendered items are of known size.
+     * Setting it causes the component to skip item measurements.
+     */
+    fixedItemHeight?: number;
+    /**
+     * Use to display placeholders if the user scrolls fast through the list.
+     *
+     * Set `components.ScrollSeekPlaceholder` to change the placeholder content.
+     */
+    scrollSeekConfiguration?: ScrollSeekConfiguration | false;
+    /**
+     * If set to `true`, the list automatically scrolls to bottom if the total count is changed.
+     * Set to `"smooth"` for an animated scrolling.
+     *
+     * By default, `followOutput` scrolls down only if the list is already at the bottom.
+     * To implement an arbitrary logic behind that, pass a function:
+     *
+     * ```tsx
+     * <Virtuoso
+     *  followOutput={(isAtBottom: boolean) => {
+     *    if (expression) {
+     *      return 'smooth' // can be 'auto' or false to avoid scrolling
+     *    } else {
+     *      return false
+     *    }
+     *  }} />
+     * ```
+     */
+    followOutput?: FollowOutput;
+    /**
+     * Use when implementing inverse infinite scrolling - decrease the value this property
+     * in combination with  `data` or `totalCount` to prepend items to the top of the list.
+     *
+     * Warning: the firstItemIndex should **be a positive number**, based on the total amount of items to be displayed.
+     */
+    firstItemIndex?: number;
+    /**
+     * Called when the list starts/stops scrolling.
+     */
+    isScrolling?: (isScrolling: boolean) => void;
+    /**
+     * Gets called when the user scrolls to the end of the list.
+     * Receives the last item index as an argument. Can be used to implement endless scrolling.
+     */
+    endReached?: (index: number) => void;
+    /**
+     * Called when the user scrolls to the start of the list.
+     */
+    startReached?: (index: number) => void;
+    /**
+     * Called with the new set of items each time the list items are rendered due to scrolling.
+     */
+    rangeChanged?: (range: ListRange) => void;
+    /**
+     * Called with true / false when the list has reached the bottom / gets scrolled up.
+     * Can be used to load newer items, like `tail -f`.
+     */
+    atBottomStateChange?: (atBottom: boolean) => void;
+    /**
+     * Called with `true` / `false` when the list has reached the top / gets scrolled down.
+     */
+    atTopStateChange?: (atTop: boolean) => void;
+    /**
+     * Called when the total list height is changed due to new items or viewport resize.
+     */
+    totalListHeightChanged?: (height: number) => void;
+    /**
+     * Called with the new set of items each time the list items are rendered due to scrolling.
+     */
+    itemsRendered?: (items: ListItem<D>[]) => void;
+    /**
+     * Setting `alignToBottom` to `true` aligns the items to the bottom of the list if the list is shorter than the viewport.
+     * Use `followOutput` property to keep the list aligned when new items are appended.
+     */
+    alignToBottom?: boolean;
+    /**
+     * Uses the document scroller rather than wrapping the list in its own.
+     */
+    useWindowScroll?: boolean;
+    /**
+     * Pass a reference to a scrollable parent element, so that the table won't wrap in its own.
+     */
+    customScrollParent?: HTMLElement;
+    /**
+     * Provides access to the root DOM element
+     */
+    scrollerRef?: (ref: HTMLElement | Window | null) => any;
+    /**
+     * By default `0`. Redefine to change how much away from the top the scroller can be before the list is not considered not at top.
+     */
+    atTopThreshold?: number;
+    /**
+     * By default `4`. Redefine to change how much away from the bottom the scroller can be before the list is not considered not at bottom.
+     */
+    atBottomThreshold?: number;
+    /**
+     * pass a state obtained from the getState() method to restore the list state - this includes the previously measured item sizes and the scroll location.
+     * Notice that you should still pass the same data and totalCount properties as before, so that the list can match the data with the stored measurements.
+     * This is useful when you want to keep the list state when the component is unmounted and remounted, for example when navigating to a different page.
+     */
+    restoreStateFrom?: StateSnapshot;
+}
+export interface TableVirtuosoHandle {
+    scrollIntoView(location: number | FlatScrollIntoViewLocation): void;
+    scrollToIndex(location: number | FlatIndexLocationWithAlign): void;
+    scrollTo(location: ScrollToOptions): void;
+    scrollBy(location: ScrollToOptions): void;
+    /**
+     * Obtains the internal size state of the component, so that it can be restored later. This does not include the data items.
+     */
+    getState(stateCb: StateCallback): void;
+}

package/components/Virtuoso/react-virtuoso/component-interfaces/TableVirtuoso.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/components/Virtuoso/react-virtuoso/component-interfaces/Virtuoso.d.ts

@@ -0,0 +1,274 @@
+import type { Components, ComputeItemKey, FlatIndexLocationWithAlign, FlatScrollIntoViewLocation, FollowOutput, GroupContent, GroupItemContent, IndexLocationWithAlign, ItemContent, ListItem, ListRange, ListRootProps, ScrollIntoViewLocation, ScrollSeekConfiguration, SizeFunction, StateSnapshot, StateCallback } from '../interfaces';
+import { LogLevel } from '../loggerSystem';
+export interface VirtuosoProps<D, C> extends ListRootProps {
+    /**
+     * The total amount of items to be rendered.
+     */
+    totalCount?: number;
+    /**
+     * The data items to be rendered. If data is set, the total count will be inferred from the length of the array.
+     */
+    data?: readonly D[];
+    /**
+     * Additional context available in the custom components and content callbacks
+     */
+    context?: C;
+    /**
+     * *The property accepts pixel values.*
+     *
+     * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+     * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+     * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+     * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
+     *
+     */
+    overscan?: number | {
+        main: number;
+        reverse: number;
+    };
+    /**
+     *
+     * *The property accepts pixel values.*
+     *
+     * Set the increaseViewportBy property to artificially increase the viewport size, causing items to be rendered before outside of the viewport.
+     * The property causes the component to render more items than the necessary, but can help with slow loading content.
+     * Using `{ top?: number, bottom?: number }` lets you set the increase for each end separately.
+     *
+     */
+    increaseViewportBy?: number | {
+        top: number;
+        bottom: number;
+    };
+    /**
+     * Set the amount of items to remain fixed at the top of the list.
+     *
+     * For a header that scrolls away when scrolling, check the `components.Header` property.
+     */
+    topItemCount?: number;
+    /**
+     * Set to a value between 0 and totalCount - 1 to make the list start scrolled to that item.
+     * Pass in an object to achieve additional effects similar to `scrollToIndex`.
+     */
+    initialTopMostItemIndex?: number | IndexLocationWithAlign;
+    /**
+     * Set this value to offset the initial location of the list.
+     * Warning: using this property will still run a render cycle at the scrollTop: 0 list window.
+     * If possible, avoid using it and stick to `initialTopMostItemIndex` instead.
+     */
+    initialScrollTop?: number;
+    /**
+     * Use for server-side rendering - if set, the list will render the specified amount of items
+     * regardless of the container / item size.
+     */
+    initialItemCount?: number;
+    /**
+     * Use the `components` property for advanced customization of the elements rendered by the list.
+     */
+    components?: Components<D, C>;
+    /**
+     * Set the callback to specify the contents of the item.
+     */
+    itemContent?: ItemContent<D, C>;
+    /**
+     * If specified, the component will use the function to generate the `key` property for each list item.
+     */
+    computeItemKey?: ComputeItemKey<D, C>;
+    /**
+     * By default, the component assumes the default item height from the first rendered item (rendering it as a "probe").
+     *
+     * If the first item turns out to be an outlier (very short or tall), the rest of the rendering will be slower,
+     * as multiple passes of rendering should happen for the list to fill the viewport.
+     *
+     * Setting `defaultItemHeight` causes the component to skip the "probe" rendering and use the property
+     * value as default height instead.
+     */
+    defaultItemHeight?: number;
+    /**
+     * Allows customizing the height/width calculation of `Item` elements.
+     *
+     * The default implementation reads `el.getBoundingClientRect().height` and `el.getBoundingClientRect().width`.
+     */
+    itemSize?: SizeFunction;
+    /**
+     * Can be used to improve performance if the rendered items are of known size.
+     * Setting it causes the component to skip item measurements.
+     */
+    fixedItemHeight?: number;
+    /**
+     * Use to display placeholders if the user scrolls fast through the list.
+     *
+     * Set `components.ScrollSeekPlaceholder` to change the placeholder content.
+     */
+    scrollSeekConfiguration?: ScrollSeekConfiguration | false;
+    /**
+     * If set to `true`, the list automatically scrolls to bottom if the total count is changed.
+     * Set to `"smooth"` for an animated scrolling.
+     *
+     * By default, `followOutput` scrolls down only if the list is already at the bottom.
+     * To implement an arbitrary logic behind that, pass a function:
+     *
+     * ```tsx
+     * <Virtuoso
+     *  followOutput={(isAtBottom: boolean) => {
+     *    if (expression) {
+     *      return 'smooth' // can be 'auto' or false to avoid scrolling
+     *    } else {
+     *      return false
+     *    }
+     *  }} />
+     * ```
+     */
+    followOutput?: FollowOutput;
+    /**
+     * Set to customize the wrapper tag for the header and footer components (default is `div`).
+     */
+    headerFooterTag?: string;
+    /**
+     * Use when implementing inverse infinite scrolling - decrease the value this property
+     * in combination with  `data` or `totalCount` to prepend items to the top of the list.
+     *
+     * Warning: the firstItemIndex should **be a positive number**, based on the total amount of items to be displayed.
+     */
+    firstItemIndex?: number;
+    /**
+     * Called when the list starts/stops scrolling.
+     */
+    isScrolling?: (isScrolling: boolean) => void;
+    /**
+     * Gets called when the user scrolls to the end of the list.
+     * Receives the last item index as an argument. Can be used to implement endless scrolling.
+     */
+    endReached?: (index: number) => void;
+    /**
+     * Called when the user scrolls to the start of the list.
+     */
+    startReached?: (index: number) => void;
+    /**
+     * Called with the new set of items each time the list items are rendered due to scrolling.
+     */
+    rangeChanged?: (range: ListRange) => void;
+    /**
+     * Called with true / false when the list has reached the bottom / gets scrolled up.
+     * Can be used to load newer items, like `tail -f`.
+     */
+    atBottomStateChange?: (atBottom: boolean) => void;
+    /**
+     * Called with `true` / `false` when the list has reached the top / gets scrolled down.
+     */
+    atTopStateChange?: (atTop: boolean) => void;
+    /**
+     * Called when the total list height is changed due to new items or viewport resize.
+     */
+    totalListHeightChanged?: (height: number) => void;
+    /**
+     * Called with the new set of items each time the list items are rendered due to scrolling.
+     */
+    itemsRendered?: (items: ListItem<D>[]) => void;
+    /**
+     * Setting `alignToBottom` to `true` aligns the items to the bottom of the list if the list is shorter than the viewport.
+     * Use `followOutput` property to keep the list aligned when new items are appended.
+     */
+    alignToBottom?: boolean;
+    /**
+     * Uses the document scroller rather than wrapping the list in its own.
+     */
+    useWindowScroll?: boolean;
+    /**
+     * Pass a reference to a scrollable parent element, so that the list won't wrap in its own.
+     */
+    customScrollParent?: HTMLElement;
+    /**
+     * Provides access to the root DOM element
+     */
+    scrollerRef?: (ref: HTMLElement | Window | null) => any;
+    /**
+     * *The property accepts pixel values.*
+     *
+     * By default `0`. Redefine to change how much away from the top the scroller can be before the list is not considered not at top.
+     */
+    atTopThreshold?: number;
+    /**
+     * *The property accepts pixel values.*
+     *
+     * By default `4`. Redefine to change how much away from the bottom the scroller can be before the list is not considered not at bottom.
+     */
+    atBottomThreshold?: number;
+    /**
+     * set to LogLevel.DEBUG to enable various diagnostics in the console, the most useful being the item measurement reports.
+     *
+     * Ensure that you have "all levels" enabled in the browser console too see the messages.
+     */
+    logLevel?: LogLevel;
+    /**
+     * pass a state obtained from the getState() method to restore the list state - this includes the previously measured item sizes and the scroll location.
+     * Notice that you should still pass the same data and totalCount properties as before, so that the list can match the data with the stored measurements.
+     * This is useful when you want to keep the list state when the component is unmounted and remounted, for example when navigating to a different page.
+     */
+    restoreStateFrom?: StateSnapshot;
+}
+export interface GroupedVirtuosoProps<D, C> extends Omit<VirtuosoProps<D, C>, 'totalCount' | 'itemContent'> {
+    /**
+     * Specifies the amount of items in each group (and, actually, how many groups are there).
+     * For example, passing [20, 30] will display 2 groups with 20 and 30 items each.
+     */
+    groupCounts?: number[];
+    /**
+     * Specifies how each each group header gets rendered. The callback receives the zero-based index of the group.
+     */
+    groupContent?: GroupContent<C>;
+    /**
+     * Specifies how each each item gets rendered.
+     */
+    itemContent?: GroupItemContent<D, C>;
+    /**
+     * Use when implementing inverse infinite scrolling, decrease the value this property
+     * in combination with a change in `groupCounts` to prepend groups items to the top of the list.
+     * Both new groups and extending the top group is supported.
+     *
+     * The delta of the firstItemIndex should equal the amount of new items introduced, without the group themselves.
+     * As an example, if you prepend 2 groups with 20 and 30 items each, the firstItemIndex should be decreased with 50.
+     *
+     * You can also prepend more items to the first group, for example:
+     * \{ groupCounts: [20, 30], firstItemIndex: 1000 \} can become \{ groupCounts: [10, 30, 30], firstItemIndex: 980 \}
+     *
+     * Warning: the firstItemIndex should **be a positive number**, based on the total amount of items to be displayed.
+     */
+    firstItemIndex?: number;
+}
+export interface VirtuosoHandle {
+    /**
+     * Scrolls the component to the specified item index. See {@link IndexLocationWithAlign} for more options.
+     */
+    scrollToIndex(location: number | FlatIndexLocationWithAlign): void;
+    /**
+     * Scrolls the item into view if necessary. See [the website example](http://virtuoso.dev/keyboard-navigation/) for an implementation.
+     */
+    scrollIntoView(location: FlatScrollIntoViewLocation): void;
+    /**
+     * Scrolls the component to the specified location. See [ScrollToOptions (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/ScrollToOptions)
+     */
+    scrollTo(location: ScrollToOptions): void;
+    /**
+     * Scrolls the component with the specified amount. See [ScrollToOptions (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/ScrollToOptions)
+     */
+    scrollBy(location: ScrollToOptions): void;
+    /**
+     * Use this with combination with follow output if you have images loading in the list. Listen to the image loading and call the method.
+     */
+    autoscrollToBottom(): void;
+    /**
+     * Obtains the internal size state of the component, so that it can be restored later. This does not include the data items.
+     */
+    getState(stateCb: StateCallback): void;
+}
+export interface GroupedVirtuosoHandle {
+    scrollToIndex(location: number | IndexLocationWithAlign): void;
+    scrollIntoView(location: number | ScrollIntoViewLocation): void;
+    scrollTo(location: ScrollToOptions): void;
+    scrollBy(location: ScrollToOptions): void;
+    autoscrollToBottom(): void;
+    /**
+     * Obtains the internal size state of the component, so that it can be restored later. This does not include the data items.
+     */
+    getState(stateCb: StateCallback): void;
+}

package/components/Virtuoso/react-virtuoso/component-interfaces/Virtuoso.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/components/Virtuoso/react-virtuoso/component-interfaces/VirtuosoGrid.d.ts

@@ -0,0 +1,125 @@
+import type { GridComponents, GridComputeItemKey, GridIndexLocation, GridItemContent, GridRootProps, ListRange, ScrollSeekConfiguration } from '../interfaces';
+import { LogLevel } from '../loggerSystem';
+export interface Gap {
+    row: number;
+    column: number;
+}
+export interface ElementDimensions {
+    width: number;
+    height: number;
+}
+export interface GridStateSnapshot {
+    viewport: ElementDimensions;
+    item: ElementDimensions;
+    gap: Gap;
+    scrollTop: number;
+}
+export interface VirtuosoGridProps<D, C = unknown> extends GridRootProps {
+    /**
+     * The total amount of items to be rendered.
+     */
+    totalCount?: number;
+    /**
+     * The data items to be rendered. If data is set, the total count will be inferred from the length of the array.
+     */
+    data?: readonly D[];
+    /**
+     * Additional context available in the custom components and content callbacks
+     */
+    context?: C;
+    /**
+     * Use for server-side rendering - if set, the list will render the specified amount of items
+     * regardless of the container / item size.
+     */
+    initialItemCount?: number;
+    /**
+     * Set the callback to specify the contents of the item.
+     */
+    itemContent?: GridItemContent<D, C>;
+    /**
+     * Use the `components` property for advanced customization of the elements rendered by the list.
+     */
+    components?: GridComponents<C>;
+    /**
+     * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+     * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+     * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+     */
+    overscan?: number | {
+        main: number;
+        reverse: number;
+    };
+    /**
+     * If specified, the component will use the function to generate the `key` property for each list item.
+     */
+    computeItemKey?: GridComputeItemKey<D, C>;
+    /**
+     * Use to display placeholders if the user scrolls fast through the list.
+     *
+     * Set `components.ScrollSeekPlaceholder` to change the placeholder content.
+     */
+    scrollSeekConfiguration?: ScrollSeekConfiguration | false;
+    /**
+     * Called when the list starts/stops scrolling.
+     */
+    isScrolling?: (isScrolling: boolean) => void;
+    /**
+     * Gets called when the user scrolls to the end of the list.
+     * Receives the last item index as an argument. Can be used to implement endless scrolling.
+     */
+    endReached?: (index: number) => void;
+    /**
+     * Called when the user scrolls to the start of the list.
+     */
+    startReached?: (index: number) => void;
+    /**
+     * Called with the new set of items each time the list items are rendered due to scrolling.
+     */
+    rangeChanged?: (range: ListRange) => void;
+    /**
+     * reports when the grid state changes. The reported value can be stored and passed back to `restoreStateFrom` to restore the grid to the same state.
+     */
+    stateChanged?: (state: GridStateSnapshot) => void;
+    restoreStateFrom?: GridStateSnapshot | undefined | null;
+    /**
+     * Called with true / false when the list has reached the bottom / gets scrolled up.
+     * Can be used to load newer items, like `tail -f`.
+     */
+    atBottomStateChange?: (atBottom: boolean) => void;
+    /**
+     * Called with `true` / `false` when the list has reached the top / gets scrolled down.
+     */
+    atTopStateChange?: (atTop: boolean) => void;
+    /**
+     * Provides access to the root DOM element
+     */
+    scrollerRef?: (ref: HTMLElement | null) => any;
+    /**
+     * Sets the className for the list DOM element
+     */
+    listClassName?: string;
+    /**
+     * Sets the grid items' className
+     */
+    itemClassName?: string;
+    /**
+     * Uses the document scroller rather than wrapping the grid in its own.
+     */
+    useWindowScroll?: boolean;
+    /**
+     * Pass a reference to a scrollable parent element, so that the grid won't wrap in its own.
+     */
+    customScrollParent?: HTMLElement;
+    /**
+     * set to LogLevel.DEBUG to enable various diagnostics in the console, the most useful being the item measurement reports.
+     *
+     * Ensure that you have "all levels" enabled in the browser console too see the messages.
+     */
+    logLevel?: LogLevel;
+    initialTopMostItemIndex?: GridIndexLocation;
+}
+export interface VirtuosoGridHandle {
+    scrollToIndex(location: GridIndexLocation): void;
+    scrollTo(location: ScrollToOptions): void;
+    scrollBy(location: ScrollToOptions): void;
+}

package/components/Virtuoso/react-virtuoso/component-interfaces/VirtuosoGrid.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/components/Virtuoso/react-virtuoso/domIOSystem.d.ts

@@ -1,14 +1,15 @@
-import * as u from '@virtuoso.dev/urx';
+import * as u from './urx';
 import { ScrollContainerState } from './interfaces';
 export declare const domIOSystem: u.SystemSpec<never[], () => {
     scrollContainerState: u.Stream<ScrollContainerState>;
     scrollTop: u.Stream<number>;
     viewportHeight: u.Stream<number>;
     headerHeight: u.StatefulStream<number>;
+    fixedHeaderHeight: u.StatefulStream<number>;
+    fixedFooterHeight: u.StatefulStream<number>;
     footerHeight: u.StatefulStream<number>;
     scrollHeight: u.Stream<number>;
     smoothScrollTargetReached: u.Stream<true>;
-    react18ConcurrentRendering: u.StatefulStream<boolean>;
     scrollTo: u.Stream<ScrollToOptions>;
     scrollBy: u.Stream<ScrollToOptions>;
     statefulScrollTop: u.StatefulStream<number>;

package/components/Virtuoso/react-virtuoso/domIOSystem.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var u = tslib_1.__importStar(require("@virtuoso.dev/urx"));
+var u = tslib_1.__importStar(require("./urx"));
 exports.domIOSystem = u.system(function () {
     var scrollContainerState = u.stream();
     var scrollTop = u.stream();
@@ -11,11 +11,12 @@ exports.domIOSystem = u.system(function () {
     var viewportHeight = u.stream();
     var scrollHeight = u.stream();
     var headerHeight = u.statefulStream(0);
+    var fixedHeaderHeight = u.statefulStream(0);
+    var fixedFooterHeight = u.statefulStream(0);
     var footerHeight = u.statefulStream(0);
     var scrollTo = u.stream();
     var scrollBy = u.stream();
     var scrollingInProgress = u.statefulStream(false);
-    var react18ConcurrentRendering = u.statefulStream(false);
     u.connect(u.pipe(scrollContainerState, u.map(function (_a) {
         var scrollTop = _a.scrollTop;
         return scrollTop;
@@ -31,10 +32,11 @@ exports.domIOSystem = u.system(function () {
         scrollTop: scrollTop,
         viewportHeight: viewportHeight,
         headerHeight: headerHeight,
+        fixedHeaderHeight: fixedHeaderHeight,
+        fixedFooterHeight: fixedFooterHeight,
         footerHeight: footerHeight,
         scrollHeight: scrollHeight,
         smoothScrollTargetReached: smoothScrollTargetReached,
-        react18ConcurrentRendering: react18ConcurrentRendering,
         // signals
         scrollTo: scrollTo,
         scrollBy: scrollBy,