@react-native-ohos/flash-list 1.8.3 → 2.1.1-rc.1

package/src/FlashListProps.ts

@@ -1,38 +1,12 @@
-/**
- * MIT License
- *
- * Copyright (C) 2024 Huawei Device Co., Ltd.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
 import type React from "react";
 import {
   StyleProp,
   ScrollViewProps,
   ViewabilityConfig,
-  ViewabilityConfigCallbackPairs,
   ViewStyle,
 } from "react-native";
 
-import { BlankAreaEventHandler } from "./native/auto-layout/AutoLayoutView";
-import ViewToken from "./viewability/ViewToken";
+import ViewToken from "./recyclerview/viewability/ViewToken";
 
 export interface ListRenderItemInfo<TItem> {
   item: TItem;
@@ -47,6 +21,12 @@ export interface ListRenderItemInfo<TItem> {
   extraData?: any;
 }
 
+export interface OverrideProps {
+  initialDrawBatchSize?: number;
+  // rest can be string to any
+  [key: string]: any;
+}
+
 export type RenderTarget = "Cell" | "StickyHeader" | "Measurement";
 
 export const RenderTargetOptions: Record<string, RenderTarget> = {
@@ -59,19 +39,21 @@ export type ListRenderItem<TItem> = (
   info: ListRenderItemInfo<TItem>
 ) => React.ReactElement | null;
 
-export type ContentStyle = Pick<
-  ViewStyle,
-  | "backgroundColor"
-  | "paddingTop"
-  | "paddingLeft"
-  | "paddingRight"
-  | "paddingBottom"
-  | "padding"
-  | "paddingVertical"
-  | "paddingHorizontal"
->;
-
-export interface FlashListProps<TItem> extends ScrollViewProps {
+export interface ViewabilityConfigCallbackPair<TItem> {
+  viewabilityConfig: ViewabilityConfig;
+  onViewableItemsChanged:
+    | ((info: {
+        viewableItems: ViewToken<TItem>[];
+        changed: ViewToken<TItem>[];
+      }) => void)
+    | null;
+}
+
+export type ViewabilityConfigCallbackPairs<TItem> =
+  ViewabilityConfigCallbackPair<TItem>[];
+
+export interface FlashListProps<TItem>
+  extends Omit<ScrollViewProps, "maintainVisibleContentPosition"> {
   /**
    * Takes an item from `data` and renders it into the list. Typical usage:
    * ```ts
@@ -94,14 +76,6 @@ export interface FlashListProps<TItem> extends ScrollViewProps {
    */
   data: ReadonlyArray<TItem> | null | undefined;
 
-  /**
-   * Average or median size for elements in the list. Doesn't have to be very accurate but a good estimate can improve performance.
-   * A quick look at `Element Inspector` can help you determine this. If you're confused between two values, the smaller value is a better choice.
-   * For vertical lists provide average height and for horizontal average width.
-   * Read more about it here: https://shopify.github.io/flash-list/docs/estimated-item-size
-   */
-  estimatedItemSize?: number;
-
   /**
    * Each cell is rendered using this element.
    * Can be a React Component Class, or a render function.
@@ -170,30 +144,11 @@ export interface FlashListProps<TItem> extends ScrollViewProps {
     | React.ComponentType<ScrollViewProps>
     | React.FC<ScrollViewProps>;
 
-  /**
-   * You can use `contentContainerStyle` to apply padding that will be applied to the whole content itself.
-   * For example, you can apply this padding, so that all of your items have leading and trailing space.
-   */
-  contentContainerStyle?: ContentStyle;
-
   /**
    * Draw distance for advanced rendering (in dp/px)
    */
   drawDistance?: number;
 
-  /**
-   * Specifies how far the first item is drawn from start of the list window or, offset of the first item of the list (not the header).
-   * Needed if you're using initialScrollIndex prop. Before the initial draw the list cannot figure out the size of header or, any special margin/padding that might have been applied
-   * using header styles etc.
-   * If this isn't provided initialScrollIndex might not scroll to the provided index.
-   */
-  estimatedFirstItemOffset?: number;
-
-  /**
-   * Visible height and width of the list. This is not the scroll content size.
-   */
-  estimatedListSize?: { height: number; width: number };
-
   /**
    * A marker property for telling the list to re-render (since it implements PureComponent).
    * If any of your `renderItem`, Header, Footer, etc. functions depend on anything outside of the `data` prop,
@@ -212,9 +167,11 @@ export interface FlashListProps<TItem> extends ScrollViewProps {
   initialScrollIndex?: number | null | undefined;
 
   /**
-   * Reverses the direction of scroll. Uses scale transforms of -1.
+   * Additional configuration for initialScrollIndex.
+   * Use viewOffset to apply an offset to the initial scroll position as defined by initialScrollIndex.
+   * Ignored if initialScrollIndex is not set.
    */
-  inverted?: boolean | null | undefined;
+  initialScrollIndexParams?: { viewOffset?: number } | null | undefined;
 
   /**
    * Used to extract a unique key for a given item at the specified index.
@@ -230,18 +187,6 @@ export interface FlashListProps<TItem> extends ScrollViewProps {
    */
   numColumns?: number | undefined;
 
-  /**
-   * Computes blank space that is visible to the user during scroll or list load. If list doesn't have enough items to fill the screen even then this will be raised.
-   * Values reported: {
-   *    offsetStart -> visible blank space on top of the screen (while going up). If value is greater than 0 then it's visible to user.
-   *    offsetEnd -> visible blank space at the end of the screen (while going down). If value is greater than 0 then it's visible to user.
-   *    blankArea -> max(offsetStart, offsetEnd) use this directly and look for values > 0
-   * }
-   * Please note that this event isn't synced with onScroll event but works with native onDraw/layoutSubviews. Events with values > 0 are blanks.
-   * This event is raised even when there is no visible blank with negative values for extensibility however, for most use cases check blankArea > 0 and use the value.
-   */
-  onBlankArea?: BlankAreaEventHandler;
-
   /**
    * Called once when the scroll position gets within onEndReachedThreshold of the rendered content.
    */
@@ -251,7 +196,7 @@ export interface FlashListProps<TItem> extends ScrollViewProps {
    * How far from the end (in units of visible length of the list) the bottom edge of the
    * list must be from the end of the content to trigger the `onEndReached` callback.
    * Thus a value of 0.5 will trigger `onEndReached` when the end of the content is
-   * within half the visible length of the list.
+   * within half the visible length of the list. Default value is 0.5.
    */
   onEndReachedThreshold?: number | null | undefined;
 
@@ -271,7 +216,10 @@ export interface FlashListProps<TItem> extends ScrollViewProps {
    * they might be deferred until JS thread is less busy.
    */
   onViewableItemsChanged?:
-    | ((info: { viewableItems: ViewToken[]; changed: ViewToken[] }) => void)
+    | ((info: {
+        viewableItems: ViewToken<TItem>[];
+        changed: ViewToken<TItem>[];
+      }) => void)
     | null
     | undefined;
 
@@ -294,11 +242,7 @@ export interface FlashListProps<TItem> extends ScrollViewProps {
   ) => string | number | undefined;
 
   /**
-   * This method can be used to provide explicit size estimates or change column span of an item.
-   *
-   * Providing specific estimates is a good idea when you can calculate sizes reliably. FlashList will prefer this value over `estimatedItemSize` for that specific item.
-   * Precise estimates will also improve precision of `scrollToIndex` method and `initialScrollIndex` prop. If you have a `separator` below your items you can include its size in the estimate.
-   *
+   * This method can be used to change column span of an item.
    * Changing item span is useful when you have grid layouts (numColumns > 1) and you want few items to be bigger than the rest.
    *
    * Modify the given layout. Do not return. FlashList will fallback to default values if this is ignored.
@@ -306,7 +250,7 @@ export interface FlashListProps<TItem> extends ScrollViewProps {
    * Performance: This method is called very frequently. Keep it fast.
    */
   overrideItemLayout?: (
-    layout: { span?: number; size?: number },
+    layout: { span?: number },
     item: TItem,
     index: number,
     maxColumns: number,
@@ -316,7 +260,7 @@ export interface FlashListProps<TItem> extends ScrollViewProps {
   /**
    * For debugging and exception use cases, internal props will be overriden with these values if used
    */
-  overrideProps?: object;
+  overrideProps?: OverrideProps;
 
   /**
    * Set this when offset is needed for the loading indicator to show correctly.
@@ -340,20 +284,85 @@ export interface FlashListProps<TItem> extends ScrollViewProps {
    * List of `ViewabilityConfig`/`onViewableItemsChanged` pairs.
    * A specific `onViewableItemsChanged` will be called when its corresponding `ViewabilityConfig`'s conditions are met.
    */
-  viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs | undefined;
+  viewabilityConfigCallbackPairs?:
+    | ViewabilityConfigCallbackPairs<TItem>
+    | undefined;
+
+  /**
+   * New arch only
+   * Maximum number of items in the recycle pool. These are the items that are cached in the recycle pool when they are scrolled off the screen.
+   * Unless you have a huge number of item types, you shouldn't need to set this.
+   * Setting this to 0, will disable the recycle pool and items will unmount once they are scrolled off the screen.
+   * There's no limit by default.
+   */
+  maxItemsInRecyclePool?: number;
+
+  /**
+   * New arch only
+   * Enable masonry layout.
+   */
+  masonry?: boolean;
+  /**
+   * New arch only
+   * If enabled, MasonryFlashList will try to reduce difference in column height by modifying item order.
+   */
+  optimizeItemArrangement?: boolean; // TODO: Check if this breaks on item resize or is glitchy
+
+  /**
+   * New arch only
+   * Called once when the scroll position gets within onStartReachedThreshold of the start of the content.
+   */
+  onStartReached?: FlashListProps<TItem>["onEndReached"];
+
+  /**
+   * New arch only
+   * How far from the start (in units of visible length of the list) the top edge of the
+   * list must be from the start of the content to trigger the `onStartReached` callback.
+   * Thus a value of 0.5 will trigger `onStartReached` when the start of the content is
+   * within half the visible length of the list. Default value is 0.2.
+   */
+  onStartReachedThreshold?: FlashListProps<TItem>["onEndReachedThreshold"];
+
+  /**
+   * New arch only
+   * Style for the RecyclerView's parent container.
+   * Please avoid anything which can mess size of children in this view. For example, margin is okay but padding is not.
+   */
+  style?: StyleProp<ViewStyle>;
 
   /**
-   * FlashList attempts to measure size of horizontal lists by drawing an extra list item in advance. This can sometimes cause issues when used with `initialScrollIndex` in lists
-   * with very little content. You might see some amount of over scroll. When set to true the list's rendered size needs to be deterministic (i.e., height and width greater than 0)
-   * as FlashList will skip rendering the extra item for measurement. Default value is `false`.
+   * New arch only
+   * Configuration for maintaining scroll position when content changes.
+   * Useful for chat-like interfaces where new messages can be added at the top or bottom.
    */
-  disableHorizontalListHeightMeasurement?: boolean;
+  maintainVisibleContentPosition?: {
+    /**
+     * maintainVisibleContentPosition is enabled by default.
+     */
+    disabled?: boolean;
+    /**
+     * When content is added at the top, automatically scroll to maintain position if the user is within this threshold of the top
+     */
+    autoscrollToTopThreshold?: number;
+    /**
+     * When content is added at the bottom, automatically scroll to maintain position if the user is within this threshold of the bottom
+     */
+    autoscrollToBottomThreshold?: number;
+    /**
+     * Scroll with animation whenever `autoscrollToBottom` is triggered. Default is `true`.
+     * Default is true.
+     */
+    animateAutoScrollToBottom?: boolean;
+    /**
+     * If true, initial render will start from the bottom of the list, useful for chat-like interfaces when there are only few messages
+     */
+    startRenderingFromBottom?: boolean;
+  };
 
   /**
-   * FlashList applies some fixes to layouts of its children which can conflict with custom `CellRendererComponent`
-   * implementations. You can disable this behavior by setting this to `true`.
-   * Recommendation: Set this to `true` while you apply special behavior to the `CellRendererComponent`. Once done set this to
-   * `false` again.
+   * New arch only
+   * Called when the layout is committed. Can be used to measure list.
+   * Doing set state inside the callback can lead to infinite loops. Make sure FlashList's props are memoized.
    */
-  disableAutoLayout?: boolean;
+  onCommitLayoutEffect?: () => void;
 }

package/src/FlashListRef.ts

@@ -0,0 +1,320 @@
+import type { RVLayout } from "./recyclerview/layout-managers/LayoutManager";
+import { RecyclerViewProps } from "./recyclerview/RecyclerViewProps";
+import { CompatScroller } from "./recyclerview/components/CompatScroller";
+
+/**
+ * Base parameters for scrolling to the edges of the list.
+ */
+export interface ScrollToEdgeParams {
+  /** Whether the scroll should be animated */
+  animated?: boolean;
+}
+
+/**
+ * Parameters for scrolling to a specific position in the list.
+ * Extends ScrollToEdgeParams to include view positioning options.
+ */
+export interface ScrollToParams extends ScrollToEdgeParams {
+  /** Position of the target item relative to the viewport (0 = top, 0.5 = center, 1 = bottom) */
+  viewPosition?: number;
+  /** Additional offset to apply after viewPosition calculation */
+  viewOffset?: number;
+}
+
+/**
+ * Parameters for scrolling to a specific offset in the list.
+ * Used when you want to scroll to an exact pixel position.
+ */
+export interface ScrollToOffsetParams extends ScrollToParams {
+  /** The pixel offset to scroll to */
+  offset: number;
+  /**
+   * If true, the first item offset will not be added to the offset calculation.
+   * First offset represents header size or top padding.
+   */
+  skipFirstItemOffset?: boolean;
+}
+
+/**
+ * Parameters for scrolling to a specific index in the list.
+ * Used when you want to scroll to a specific item by its position in the data array.
+ */
+export interface ScrollToIndexParams extends ScrollToParams {
+  /** The index of the item to scroll to */
+  index: number;
+}
+
+/**
+ * Parameters for scrolling to a specific item in the list.
+ * Used when you want to scroll to a specific item by its data value.
+ */
+export interface ScrollToItemParams<T> extends ScrollToParams {
+  /** The item to scroll to */
+  item: T;
+}
+
+/**
+ * Interface for FlashList's ref object that provides imperative methods
+ * for controlling list behavior.
+ *
+ * Usage example:
+ * ```tsx
+ * const listRef = useRef<FlashListRef<ItemType>>(null);
+ *
+ * // Later in your component
+ * <FlashList
+ *   ref={listRef}
+ *   data={data}
+ *   renderItem={renderItem}
+ * />
+ *
+ * // Somewhere else in your component
+ * listRef.current?.scrollToIndex({ index: 5, animated: true });
+ * ```
+ */
+export interface FlashListRef<T> {
+  /**
+   * Get access to current props
+   */
+  props: RecyclerViewProps<T>;
+  /**
+   * Scrolls the list to a specific offset position.
+   *
+   * Use this method when you want precise control over the scroll position in pixels
+   * rather than by item index.
+   *
+   * @param params - Parameters for scrolling to offset
+   * @param params.offset - The pixel offset to scroll to
+   * @param params.animated - Whether the scroll should be animated (default: false)
+   * @param params.skipFirstItemOffset - If true, the first item offset (headers/padding)
+   *                                    will not be included in calculation (default: true)
+   *
+   * @example
+   * // Scroll to 200px from the top/left
+   * listRef.current?.scrollToOffset({ offset: 200, animated: true });
+   */
+  scrollToOffset: (params: ScrollToOffsetParams) => void;
+
+  /**
+   * Makes the scroll indicators flash momentarily.
+   *
+   * Useful to indicate to users that there is more content to scroll.
+   *
+   * @example
+   * listRef.current?.flashScrollIndicators();
+   */
+  flashScrollIndicators: () => void;
+
+  /**
+   * Returns the underlying native scroll view reference.
+   *
+   * Use this when you need direct access to the native scroll component.
+   * This is generally not recommended for regular use.
+   *
+   * @returns The native scroll view reference
+   */
+  getNativeScrollRef: () => CompatScroller | null;
+
+  /**
+   * Returns a reference to the scroll responder.
+   *
+   * Useful for more advanced scroll handling and integrations.
+   *
+   * @returns The scroll responder
+   */
+  getScrollResponder: CompatScroller["getScrollResponder"];
+
+  /**
+   * Returns the underlying scrollable node.
+   *
+   * Primarily used for platform-specific integrations.
+   *
+   * @returns The scrollable node
+   */
+  getScrollableNode: () => any;
+
+  /**
+   * Scrolls to the end of the list.
+   *
+   * @param params - Optional parameters for scrolling
+   * @param params.animated - Whether the scroll should be animated (default: false)
+   *
+   * @example
+   * // Animate scroll to the end of the list
+   * listRef.current?.scrollToEnd({ animated: true });
+   */
+  scrollToEnd: (params?: ScrollToEdgeParams) => void;
+
+  /**
+   * Scrolls to the top (or start) of the list.
+   *
+   * @param params - Optional parameters for scrolling
+   * @param params.animated - Whether the scroll should be animated (default: false)
+   *
+   * @example
+   * // Smoothly scroll to the top
+   * listRef.current?.scrollToTop({ animated: true });
+   */
+  scrollToTop: (params?: ScrollToEdgeParams) => void;
+
+  /**
+   * Scrolls to a specific index in the list.
+   *
+   * This is the most common method to scroll to a particular item.
+   *
+   * @param params - Parameters for scrolling to index
+   * @param params.index - The index of the item to scroll to
+   * @param params.animated - Whether the scroll should be animated (default: false)
+   * @param params.viewPosition - Position of the item within the visible area:
+   *                              0 = top/left, 0.5 = center, 1 = bottom/right (default: 0)
+   * @param params.viewOffset - Additional offset to apply after viewPosition calculation
+   *
+   * @returns A Promise that resolves when the scroll operation is complete
+   *
+   * @example
+   * // Scroll to the 5th item (index 4) and center it
+   * listRef.current?.scrollToIndex({
+   *   index: 4,
+   *   animated: true,
+   *   viewPosition: 0.5
+   * });
+   */
+  scrollToIndex: (params: ScrollToIndexParams) => Promise<void>;
+
+  /**
+   * Scrolls to a specific item in the list.
+   *
+   * Similar to scrollToIndex, but works with the item reference instead of its index.
+   * Useful when you have a reference to an item but don't know its index.
+   *
+   * @param params - Parameters for scrolling to item
+   * @param params.item - The item object to scroll to
+   * @param params.animated - Whether the scroll should be animated (default: false)
+   * @param params.viewPosition - Position of the item within the visible area:
+   *                              0 = top/left, 0.5 = center, 1 = bottom/right (default: 0)
+   * @param params.viewOffset - Additional offset to apply after viewPosition calculation
+   *
+   * @example
+   * // Scroll to a specific item
+   * const targetItem = data[10];
+   * listRef.current?.scrollToItem({
+   *   item: targetItem,
+   *   animated: true
+   * });
+   */
+  scrollToItem: (params: ScrollToItemParams<T>) => void;
+
+  /**
+   * Returns the offset of the first item (accounts for header/padding).
+   *
+   * Useful when implementing custom scroll behavior or calculating positions.
+   *
+   * @returns The pixel offset of the first item
+   */
+  getFirstItemOffset: () => number;
+
+  /**
+   * Returns the current viewport dimensions.
+   *
+   * @returns An object with width and height properties representing viewport size
+   */
+  getWindowSize: () => { width: number; height: number };
+
+  /**
+   * Returns the layout information for a specific item.
+   *
+   * Use this to get position and size information for an item at a given index.
+   *
+   * @param index - The index of the item to get layout information for
+   * @returns Layout information including x, y, width, and height
+   *
+   * @example
+   * const itemLayout = listRef.current?.getLayout(5);
+   * console.log(`Item 5 position: (${itemLayout.x}, ${itemLayout.y})`);
+   */
+  getLayout: (index: number) => RVLayout | undefined;
+
+  /**
+   * Returns the absolute last scroll offset.
+   *
+   * Useful for implementing custom scroll tracking functionality.
+   *
+   * @returns The last scroll offset in pixels
+   */
+  getAbsoluteLastScrollOffset: () => number;
+
+  /**
+   * Returns the dimensions of the child container.
+   *
+   * @returns An object with width and height properties
+   */
+  getChildContainerDimensions: () => { width: number; height: number };
+
+  /**
+   * Marks the list as having been interacted with.
+   *
+   * Call this method when you want to manually trigger the onViewableItemsChanged
+   * callback without an actual scroll event.
+   */
+  recordInteraction: () => void;
+
+  /**
+   * Returns the currently visible item indices.
+   *
+   * Use this to determine which items are currently visible to the user.
+   *
+   * @returns An object with startIndex and endIndex properties
+   *
+   * @example
+   * const { startIndex, endIndex } = listRef.current?.getVisibleIndices();
+   * console.log(`Visible items: ${startIndex} to ${endIndex}`);
+   */
+  computeVisibleIndices: () => { startIndex: number; endIndex: number };
+
+  /**
+   * Returns the index of the first visible item.
+   *
+   * Convenience method when you only need the first visible item.
+   *
+   * @returns The index of the first visible item
+   *
+   * @example
+   * const firstVisibleIndex = listRef.current?.getFirstVisibleIndex();
+   */
+  getFirstVisibleIndex: () => number;
+
+  /**
+   * Forces recalculation of viewable items (vieability callbacks).
+   *
+   * Call this after any operation that might affect item visibility but
+   * doesn't trigger a scroll event.
+   *
+   * @example
+   * // After manually changing item sizes
+   * listRef.current?.recomputeViewableItems();
+   */
+  recomputeViewableItems: () => void;
+
+  /**
+   * Disables item recycling in preparation for layout animations.
+   *
+   * Call this before performing layout animations to prevent visual glitches.
+   * Remember to reset disableRecycling after animations complete.
+   *
+   * @example
+   * // Before starting layout animations
+   * listRef.current?.prepareForLayoutAnimationRender();
+   */
+  prepareForLayoutAnimationRender: () => void;
+
+  /**
+   * Clears the layout cache on update.
+   * Call this when you want to clear the layout cache on update.
+   * Can be useful for carousals when orientation changes.
+   * This should be called before the render and not in an effect.
+   *
+   * @example
+   * listRef.current?.clearLayoutCacheOnUpdate();
+   */
+  clearLayoutCacheOnUpdate: () => void;
+}

package/src/benchmark/AutoScrollHelper.ts

@@ -1,27 +1,3 @@
-/**
- * MIT License
- *
- * Copyright (C) 2024 Huawei Device Co., Ltd.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
 /**
  * This method can be used to trigger scroll events that can be forwarded to an element. Anything that implements scrollable can leverage this.
  * @param scroll The scrollable element