@pega/lists-react 9.0.0-build.6.9 → 9.0.0-build.7.1

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/usePagination.js

@@ -0,0 +1,55 @@
+import { useCallback, useState } from 'react';
+import { getDataIndex, getVirtualizedPaginationIndices } from './utils';
+/**
+ * Calculates the indices of items to render based on the current scroll position,
+ * buffer, and virtualization settings. It triggers data fetching via the provided `apiCallback`
+ * when pagination boundaries change or a force refresh is requested.
+ *
+ * @returns An object containing:
+ * - `triggerPagination`: Function to recalculate pagination indices and trigger data fetching.
+ * - `isForceRefreshedPagination`: Boolean indicating if the last pagination was force-refreshed.
+ */
+export default function usePagination({ apiCallback, id, buffer, maxItemsToPaint, startIndex, endIndex, virtualizedCount, isInfiniteMode, itemsHeight, defaultItemHeight, parentContainerRef, itemContainerRef, setStartIndex, setEndIndex, previousFirstItemDataIndexRef }) {
+    const [isForceRefreshedPagination, setIsForceRefreshedPagination] = useState(false);
+    const triggerPagination = useCallback((currentScrollTop, forceRefresh) => {
+        setIsForceRefreshedPagination(!!forceRefresh);
+        const { startIndex: newStartIndex, endIndex: newEndIndex } = getVirtualizedPaginationIndices({
+            scrollTop: currentScrollTop,
+            containerRef: parentContainerRef,
+            itemContainerRef,
+            totalItemCount: virtualizedCount,
+            itemsHeight,
+            defaultItemHeight,
+            buffer,
+            endIndexLimit: maxItemsToPaint,
+            isInfiniteMode
+        });
+        // Prevent redundant fetch
+        if (!forceRefresh && endIndex > 0 && newStartIndex >= startIndex && newEndIndex <= endIndex) {
+            return;
+        }
+        if (virtualizedCount === 0) {
+            previousFirstItemDataIndexRef.current = 0;
+        }
+        else if (itemContainerRef.current?.children[0]) {
+            const firstItemDataIndex = getDataIndex(itemContainerRef.current.children[0]);
+            previousFirstItemDataIndexRef.current = firstItemDataIndex ?? 0;
+        }
+        setStartIndex(newStartIndex);
+        setEndIndex(newEndIndex);
+        apiCallback({ startIndex: newStartIndex, endIndex: newEndIndex, id }, { takeLatestAction: true });
+    }, [
+        virtualizedCount,
+        isInfiniteMode,
+        buffer,
+        maxItemsToPaint,
+        startIndex,
+        endIndex,
+        apiCallback,
+        id,
+        itemsHeight,
+        defaultItemHeight
+    ]);
+    return { triggerPagination, isForceRefreshedPagination };
+}
+//# sourceMappingURL=usePagination.js.map

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/usePagination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePagination.js","sourceRoot":"","sources":["../../../../../Core/Components/Virtualise/VariableHeightVirtualizer/usePagination.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAI9C,OAAO,EAAE,YAAY,EAAE,+BAA+B,EAAE,MAAM,SAAS,CAAC;AAmCxE;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,EACpC,WAAW,EACX,EAAE,EACF,MAAM,EACN,eAAe,EACf,UAAU,EACV,QAAQ,EACR,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,aAAa,EACb,WAAW,EACX,6BAA6B,EACZ;IACjB,MAAM,CAAC,0BAA0B,EAAE,6BAA6B,CAAC,GAAG,QAAQ,CAAU,KAAK,CAAC,CAAC;IAE7F,MAAM,iBAAiB,GAAG,WAAW,CACnC,CAAC,gBAAwB,EAAE,YAAsB,EAAE,EAAE;QACnD,6BAA6B,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;QAC9C,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,+BAA+B,CAAC;YAC3F,SAAS,EAAE,gBAAgB;YAC3B,YAAY,EAAE,kBAAkB;YAChC,gBAAgB;YAChB,cAAc,EAAE,gBAAgB;YAChC,WAAW;YACX,iBAAiB;YACjB,MAAM;YACN,aAAa,EAAE,eAAe;YAC9B,cAAc;SACf,CAAC,CAAC;QAEH,0BAA0B;QAC1B,IAAI,CAAC,YAAY,IAAI,QAAQ,GAAG,CAAC,IAAI,aAAa,IAAI,UAAU,IAAI,WAAW,IAAI,QAAQ,EAAE,CAAC;YAC5F,OAAO;QACT,CAAC;QAED,IAAI,gBAAgB,KAAK,CAAC,EAAE,CAAC;YAC3B,6BAA6B,CAAC,OAAO,GAAG,CAAC,CAAC;QAC5C,CAAC;aAAM,IAAI,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;YACjD,MAAM,kBAAkB,GAAG,YAAY,CAAC,gBAAgB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;YAC9E,6BAA6B,CAAC,OAAO,GAAG,kBAAkB,IAAI,CAAC,CAAC;QAClE,CAAC;QAED,aAAa,CAAC,aAAa,CAAC,CAAC;QAC7B,WAAW,CAAC,WAAW,CAAC,CAAC;QACzB,WAAW,CACT,EAAE,UAAU,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,EAAE,EAAE,EACxD,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAC3B,CAAC;IACJ,CAAC,EACD;QACE,gBAAgB;QAChB,cAAc;QACd,MAAM;QACN,eAAe;QACf,UAAU;QACV,QAAQ;QACR,WAAW;QACX,EAAE;QACF,WAAW;QACX,iBAAiB;KAClB,CACF,CAAC;IAEF,OAAO,EAAE,iBAAiB,EAAE,0BAA0B,EAAE,CAAC;AAC3D,CAAC","sourcesContent":["import { useCallback, useState } from 'react';\nimport type { MutableRefObject, RefObject } from 'react';\n\nimport type { ItemsHeight, VariableHeightVirtualizerProps } from './VariableHeightVirtualizer';\nimport { getDataIndex, getVirtualizedPaginationIndices } from './utils';\n\ninterface PaginationParams {\n  /** Callback to fetch paginated data. */\n  apiCallback: VariableHeightVirtualizerProps['apiCallback'];\n  /** Unique identifier for the virtualizer instance. */\n  id: string;\n  /** Number of items to buffer before/after the visible range. */\n  buffer: number;\n  /** Maximum number of items to render at once. */\n  maxItemsToPaint: number;\n  /** Current start index of the visible items. */\n  startIndex: number;\n  /** Current end index of the visible items. */\n  endIndex: number;\n  /** Total number of items in the virtualized list. */\n  virtualizedCount: number;\n  /** Whether infinite scrolling mode is enabled. */\n  isInfiniteMode: boolean;\n  /** Mapping of item indices and their actual height. */\n  itemsHeight: ItemsHeight;\n  /** Default height for items if not measured. */\n  defaultItemHeight: number;\n  /** Ref to the parent scrollable container element. */\n  parentContainerRef: RefObject<HTMLElement>;\n  /** Ref to the container holding the rendered items. */\n  itemContainerRef: RefObject<HTMLElement>;\n  /** Setter for the start index. */\n  setStartIndex: (v: number) => void;\n  /** Setter for the end index. */\n  setEndIndex: (v: number) => void;\n  /** Ref to track the previous first item's data index. */\n  previousFirstItemDataIndexRef: MutableRefObject<number | null>;\n}\n\n/**\n * Calculates the indices of items to render based on the current scroll position,\n * buffer, and virtualization settings. It triggers data fetching via the provided `apiCallback`\n * when pagination boundaries change or a force refresh is requested.\n *\n * @returns An object containing:\n * - `triggerPagination`: Function to recalculate pagination indices and trigger data fetching.\n * - `isForceRefreshedPagination`: Boolean indicating if the last pagination was force-refreshed.\n */\nexport default function usePagination({\n  apiCallback,\n  id,\n  buffer,\n  maxItemsToPaint,\n  startIndex,\n  endIndex,\n  virtualizedCount,\n  isInfiniteMode,\n  itemsHeight,\n  defaultItemHeight,\n  parentContainerRef,\n  itemContainerRef,\n  setStartIndex,\n  setEndIndex,\n  previousFirstItemDataIndexRef\n}: PaginationParams) {\n  const [isForceRefreshedPagination, setIsForceRefreshedPagination] = useState<boolean>(false);\n\n  const triggerPagination = useCallback(\n    (currentScrollTop: number, forceRefresh?: boolean) => {\n      setIsForceRefreshedPagination(!!forceRefresh);\n      const { startIndex: newStartIndex, endIndex: newEndIndex } = getVirtualizedPaginationIndices({\n        scrollTop: currentScrollTop,\n        containerRef: parentContainerRef,\n        itemContainerRef,\n        totalItemCount: virtualizedCount,\n        itemsHeight,\n        defaultItemHeight,\n        buffer,\n        endIndexLimit: maxItemsToPaint,\n        isInfiniteMode\n      });\n\n      // Prevent redundant fetch\n      if (!forceRefresh && endIndex > 0 && newStartIndex >= startIndex && newEndIndex <= endIndex) {\n        return;\n      }\n\n      if (virtualizedCount === 0) {\n        previousFirstItemDataIndexRef.current = 0;\n      } else if (itemContainerRef.current?.children[0]) {\n        const firstItemDataIndex = getDataIndex(itemContainerRef.current.children[0]);\n        previousFirstItemDataIndexRef.current = firstItemDataIndex ?? 0;\n      }\n\n      setStartIndex(newStartIndex);\n      setEndIndex(newEndIndex);\n      apiCallback(\n        { startIndex: newStartIndex, endIndex: newEndIndex, id },\n        { takeLatestAction: true }\n      );\n    },\n    [\n      virtualizedCount,\n      isInfiniteMode,\n      buffer,\n      maxItemsToPaint,\n      startIndex,\n      endIndex,\n      apiCallback,\n      id,\n      itemsHeight,\n      defaultItemHeight\n    ]\n  );\n\n  return { triggerPagination, isForceRefreshedPagination };\n}\n"]}

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/useScroll.d.ts

@@ -0,0 +1,21 @@
+import type { RefObject } from 'react';
+interface ScrollProps {
+    /** Ref to the parent scrollable container element. */
+    parentContainerRef: RefObject<HTMLElement>;
+    /** Ref to the container holding the rendered elements. */
+    itemContainerRef: RefObject<HTMLElement>;
+    /**
+     * Callback invoked when the scroll position is near the top or bottom threshold.
+     * @param scrollTop - The current scrollTop value of the parent container.
+     */
+    onThresholdBreach: (scrollTop: number) => void;
+    /** Optional throttle delay for scroll events (default: 150ms). */
+    delay?: number;
+}
+/**
+ * Hook to monitor scroll events on a parent container and trigger a callback
+ * when the scroll position approaches the top or bottom threshold of the child elements.
+ */
+export default function useScroll({ parentContainerRef, itemContainerRef, onThresholdBreach, delay }: ScrollProps): void;
+export {};
+//# sourceMappingURL=useScroll.d.ts.map

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/useScroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useScroll.d.ts","sourceRoot":"","sources":["../../../../../Core/Components/Virtualise/VariableHeightVirtualizer/useScroll.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,UAAU,WAAW;IACnB,sDAAsD;IACtD,kBAAkB,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;IAC3C,0DAA0D;IAC1D,gBAAgB,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;IACzC;;;OAGG;IACH,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,kEAAkE;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,EAChC,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,KAAW,EACZ,EAAE,WAAW,QAyCb"}

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/useScroll.js

@@ -0,0 +1,39 @@
+import { useEffect, useState } from 'react';
+import useThrottle from '../../../Hooks/useThrottle';
+/**
+ * Hook to monitor scroll events on a parent container and trigger a callback
+ * when the scroll position approaches the top or bottom threshold of the child elements.
+ */
+export default function useScroll({ parentContainerRef, itemContainerRef, onThresholdBreach, delay = 150 }) {
+    const [scrollPos, setScrollPos] = useState();
+    useThrottle(scrollPos, () => {
+        if (!parentContainerRef.current || !itemContainerRef.current)
+            return;
+        const children = Array.from(itemContainerRef.current.children);
+        if (!children.length)
+            return;
+        const topIndex = Math.floor(children.length * 0.1);
+        const bottomIndex = Math.floor(children.length * 0.9);
+        const topAnchorElement = children[topIndex];
+        const bottomAnchorElement = children[bottomIndex];
+        const topRect = topAnchorElement.getBoundingClientRect();
+        const bottomRect = bottomAnchorElement.getBoundingClientRect();
+        const parentRect = parentContainerRef.current.getBoundingClientRect();
+        const nearTop = topRect.bottom >= parentRect.top;
+        const nearBottom = bottomRect.top <= parentRect.bottom;
+        if (nearTop || nearBottom) {
+            onThresholdBreach(parentContainerRef.current.scrollTop);
+        }
+    }, delay);
+    useEffect(() => {
+        const scrollElement = parentContainerRef.current;
+        if (!scrollElement)
+            return;
+        const scrollHandler = () => setScrollPos(scrollElement.scrollTop);
+        scrollElement.addEventListener('scroll', scrollHandler, { passive: true });
+        return () => {
+            scrollElement.removeEventListener('scroll', scrollHandler);
+        };
+    }, [parentContainerRef]);
+}
+//# sourceMappingURL=useScroll.js.map

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/useScroll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useScroll.js","sourceRoot":"","sources":["../../../../../Core/Components/Virtualise/VariableHeightVirtualizer/useScroll.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAG5C,OAAO,WAAW,MAAM,4BAA4B,CAAC;AAgBrD;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,EAChC,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,GAAG,GAAG,EACC;IACZ,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,EAAsB,CAAC;IAEjE,WAAW,CACT,SAAS,EACT,GAAG,EAAE;QACH,IAAI,CAAC,kBAAkB,CAAC,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO;YAAE,OAAO;QAErE,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC/D,IAAI,CAAC,QAAQ,CAAC,MAAM;YAAE,OAAO;QAE7B,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC;QACnD,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC;QAEtD,MAAM,gBAAgB,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC5C,MAAM,mBAAmB,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC;QAElD,MAAM,OAAO,GAAG,gBAAgB,CAAC,qBAAqB,EAAE,CAAC;QACzD,MAAM,UAAU,GAAG,mBAAmB,CAAC,qBAAqB,EAAE,CAAC;QAE/D,MAAM,UAAU,GAAG,kBAAkB,CAAC,OAAO,CAAC,qBAAqB,EAAE,CAAC;QACtE,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,IAAI,UAAU,CAAC,GAAG,CAAC;QACjD,MAAM,UAAU,GAAG,UAAU,CAAC,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC;QAEvD,IAAI,OAAO,IAAI,UAAU,EAAE,CAAC;YAC1B,iBAAiB,CAAC,kBAAkB,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC1D,CAAC;IACH,CAAC,EACD,KAAK,CACN,CAAC;IACF,SAAS,CAAC,GAAG,EAAE;QACb,MAAM,aAAa,GAAG,kBAAkB,CAAC,OAAO,CAAC;QACjD,IAAI,CAAC,aAAa;YAAE,OAAO;QAE3B,MAAM,aAAa,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QAClE,aAAa,CAAC,gBAAgB,CAAC,QAAQ,EAAE,aAAa,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;QAE3E,OAAO,GAAG,EAAE;YACV,aAAa,CAAC,mBAAmB,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QAC7D,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC;AAC3B,CAAC","sourcesContent":["import { useEffect, useState } from 'react';\nimport type { RefObject } from 'react';\n\nimport useThrottle from '../../../Hooks/useThrottle';\n\ninterface ScrollProps {\n  /** Ref to the parent scrollable container element. */\n  parentContainerRef: RefObject<HTMLElement>;\n  /** Ref to the container holding the rendered elements. */\n  itemContainerRef: RefObject<HTMLElement>;\n  /**\n   * Callback invoked when the scroll position is near the top or bottom threshold.\n   * @param scrollTop - The current scrollTop value of the parent container.\n   */\n  onThresholdBreach: (scrollTop: number) => void;\n  /** Optional throttle delay for scroll events (default: 150ms). */\n  delay?: number;\n}\n\n/**\n * Hook to monitor scroll events on a parent container and trigger a callback\n * when the scroll position approaches the top or bottom threshold of the child elements.\n */\nexport default function useScroll({\n  parentContainerRef,\n  itemContainerRef,\n  onThresholdBreach,\n  delay = 150\n}: ScrollProps) {\n  const [scrollPos, setScrollPos] = useState<number | undefined>();\n\n  useThrottle(\n    scrollPos,\n    () => {\n      if (!parentContainerRef.current || !itemContainerRef.current) return;\n\n      const children = Array.from(itemContainerRef.current.children);\n      if (!children.length) return;\n\n      const topIndex = Math.floor(children.length * 0.1);\n      const bottomIndex = Math.floor(children.length * 0.9);\n\n      const topAnchorElement = children[topIndex];\n      const bottomAnchorElement = children[bottomIndex];\n\n      const topRect = topAnchorElement.getBoundingClientRect();\n      const bottomRect = bottomAnchorElement.getBoundingClientRect();\n\n      const parentRect = parentContainerRef.current.getBoundingClientRect();\n      const nearTop = topRect.bottom >= parentRect.top;\n      const nearBottom = bottomRect.top <= parentRect.bottom;\n\n      if (nearTop || nearBottom) {\n        onThresholdBreach(parentContainerRef.current.scrollTop);\n      }\n    },\n    delay\n  );\n  useEffect(() => {\n    const scrollElement = parentContainerRef.current;\n    if (!scrollElement) return;\n\n    const scrollHandler = () => setScrollPos(scrollElement.scrollTop);\n    scrollElement.addEventListener('scroll', scrollHandler, { passive: true });\n\n    return () => {\n      scrollElement.removeEventListener('scroll', scrollHandler);\n    };\n  }, [parentContainerRef]);\n}\n"]}

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/useVirtualizerItemCount.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode, type RefObject } from 'react';
+import type { LoadedDataRange } from './VariableHeightVirtualizer';
+interface VirtualizerItemCountParams {
+    /** The starting index requested by virtualizer. */
+    startIndex: number;
+    /** The ending index requested by virtualizer. */
+    endIndex: number;
+    /** The range of items currently loaded. */
+    loadedDataRange: LoadedDataRange;
+    /** Indicates if the data is currently being fetched. */
+    isDataFetching: boolean;
+    /** Ref to the container holding rendered items. */
+    itemContainerRef: RefObject<HTMLElement>;
+    /** The rendered children items as ReactNode. */
+    children: ReactNode;
+    /** The total number of items if known, or `null`/`undefined` for infinite mode. */
+    totalItemCount?: number | null;
+    /** Optional buffer to add to the count in infinite mode. */
+    buffer?: number;
+    /** Signal to reset the count in infinite mode. */
+    countResetSignal?: number;
+}
+/**
+ * Determines the count of virtualized items in a list and whether the list is in infinite scrolling mode or not.
+ *
+ * @returns An object containing:
+ * - `isInfiniteMode`: Whether the list is in infinite scrolling mode.
+ * - `virtualizedCount`: The current count of virtualized items.
+ *
+ * NOTE: In finite mode, the count is based on `totalItemCount`.
+ * NOTE: In infinite mode, the count is dynamically calculated based on loaded items and buffer.
+ */
+export default function useVirtualizerItemCount(params: VirtualizerItemCountParams): {
+    isInfiniteMode: boolean;
+    virtualizedCount: number;
+};
+export {};
+//# sourceMappingURL=useVirtualizerItemCount.d.ts.map

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/useVirtualizerItemCount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVirtualizerItemCount.d.ts","sourceRoot":"","sources":["../../../../../Core/Components/Virtualise/VariableHeightVirtualizer/useVirtualizerItemCount.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAGnE,UAAU,0BAA0B;IAClC,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,2CAA2C;IAC3C,eAAe,EAAE,eAAe,CAAC;IACjC,wDAAwD;IACxD,cAAc,EAAE,OAAO,CAAC;IAExB,mDAAmD;IACnD,gBAAgB,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;IACzC,gDAAgD;IAChD,QAAQ,EAAE,SAAS,CAAC;IAEpB,mFAAmF;IACnF,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,MAAM,EAAE,0BAA0B,GAAG;IACnF,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAwEA"}

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/useVirtualizerItemCount.js

@@ -0,0 +1,62 @@
+import { useEffect, useLayoutEffect, useMemo, useState } from 'react';
+import { getDataIndex } from './utils';
+/**
+ * Determines the count of virtualized items in a list and whether the list is in infinite scrolling mode or not.
+ *
+ * @returns An object containing:
+ * - `isInfiniteMode`: Whether the list is in infinite scrolling mode.
+ * - `virtualizedCount`: The current count of virtualized items.
+ *
+ * NOTE: In finite mode, the count is based on `totalItemCount`.
+ * NOTE: In infinite mode, the count is dynamically calculated based on loaded items and buffer.
+ */
+export default function useVirtualizerItemCount(params) {
+    const { startIndex, endIndex, loadedDataRange, isDataFetching, totalItemCount, buffer = 10, countResetSignal, itemContainerRef, children } = params;
+    const [virtualizedCount, setVirtualizedCount] = useState(totalItemCount || 0);
+    const isInfiniteMode = useMemo(() => totalItemCount === null || totalItemCount === undefined, [totalItemCount]);
+    useLayoutEffect(() => {
+        if (!isInfiniteMode) {
+            setVirtualizedCount(totalItemCount ?? 0);
+        }
+    }, [totalItemCount, isInfiniteMode]);
+    useLayoutEffect(() => {
+        if (isInfiniteMode) {
+            setVirtualizedCount(0);
+        }
+    }, [countResetSignal, isInfiniteMode]);
+    // Calculating count based on loaded items for infinite scrolling
+    useEffect(() => {
+        if (!isInfiniteMode || !endIndex || !loadedDataRange.endIndex || isDataFetching)
+            return;
+        const items = itemContainerRef.current?.children;
+        if (!items?.length) {
+            setVirtualizedCount(0);
+            return;
+        }
+        const lastItemDataIndex = getDataIndex(items[items.length - 1]) ?? -1;
+        const hasMoreResults = loadedDataRange.startIndex === startIndex &&
+            loadedDataRange.endIndex === endIndex &&
+            lastItemDataIndex === endIndex;
+        if (!hasMoreResults && Number.isInteger(lastItemDataIndex)) {
+            setVirtualizedCount(lastItemDataIndex + 1);
+            return;
+        }
+        const countWithBuffer = loadedDataRange.endIndex + 1 + buffer;
+        if (hasMoreResults && countWithBuffer > virtualizedCount) {
+            setVirtualizedCount(countWithBuffer);
+        }
+    }, [
+        isDataFetching,
+        children,
+        isInfiniteMode,
+        loadedDataRange,
+        virtualizedCount,
+        itemContainerRef,
+        endIndex
+    ]);
+    return {
+        isInfiniteMode,
+        virtualizedCount
+    };
+}
+//# sourceMappingURL=useVirtualizerItemCount.js.map

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/useVirtualizerItemCount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVirtualizerItemCount.js","sourceRoot":"","sources":["../../../../../Core/Components/Virtualise/VariableHeightVirtualizer/useVirtualizerItemCount.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,eAAe,EACf,OAAO,EACP,QAAQ,EAGT,MAAM,OAAO,CAAC;AAGf,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAyBvC;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,MAAkC;IAIhF,MAAM,EACJ,UAAU,EACV,QAAQ,EACR,eAAe,EACf,cAAc,EACd,cAAc,EACd,MAAM,GAAG,EAAE,EACX,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EACT,GAAG,MAAM,CAAC;IAEX,MAAM,CAAC,gBAAgB,EAAE,mBAAmB,CAAC,GAAG,QAAQ,CAAC,cAAc,IAAI,CAAC,CAAC,CAAC;IAE9E,MAAM,cAAc,GAAG,OAAO,CAC5B,GAAG,EAAE,CAAC,cAAc,KAAK,IAAI,IAAI,cAAc,KAAK,SAAS,EAC7D,CAAC,cAAc,CAAC,CACjB,CAAC;IAEF,eAAe,CAAC,GAAG,EAAE;QACnB,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,mBAAmB,CAAC,cAAc,IAAI,CAAC,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC,EAAE,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC;IAErC,eAAe,CAAC,GAAG,EAAE;QACnB,IAAI,cAAc,EAAE,CAAC;YACnB,mBAAmB,CAAC,CAAC,CAAC,CAAC;QACzB,CAAC;IACH,CAAC,EAAE,CAAC,gBAAgB,EAAE,cAAc,CAAC,CAAC,CAAC;IAEvC,iEAAiE;IACjE,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,cAAc,IAAI,CAAC,QAAQ,IAAI,CAAC,eAAe,CAAC,QAAQ,IAAI,cAAc;YAAE,OAAO;QAExF,MAAM,KAAK,GAAG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC;QACjD,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;YACnB,mBAAmB,CAAC,CAAC,CAAC,CAAC;YACvB,OAAO;QACT,CAAC;QAED,MAAM,iBAAiB,GAAG,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAEtE,MAAM,cAAc,GAClB,eAAe,CAAC,UAAU,KAAK,UAAU;YACzC,eAAe,CAAC,QAAQ,KAAK,QAAQ;YACrC,iBAAiB,KAAK,QAAQ,CAAC;QAEjC,IAAI,CAAC,cAAc,IAAI,MAAM,CAAC,SAAS,CAAC,iBAAiB,CAAC,EAAE,CAAC;YAC3D,mBAAmB,CAAC,iBAAiB,GAAG,CAAC,CAAC,CAAC;YAC3C,OAAO;QACT,CAAC;QAED,MAAM,eAAe,GAAG,eAAe,CAAC,QAAQ,GAAG,CAAC,GAAG,MAAM,CAAC;QAC9D,IAAI,cAAc,IAAI,eAAe,GAAG,gBAAgB,EAAE,CAAC;YACzD,mBAAmB,CAAC,eAAe,CAAC,CAAC;QACvC,CAAC;IACH,CAAC,EAAE;QACD,cAAc;QACd,QAAQ;QACR,cAAc;QACd,eAAe;QACf,gBAAgB;QAChB,gBAAgB;QAChB,QAAQ;KACT,CAAC,CAAC;IAEH,OAAO;QACL,cAAc;QACd,gBAAgB;KACjB,CAAC;AACJ,CAAC","sourcesContent":["import {\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useState,\n  type ReactNode,\n  type RefObject\n} from 'react';\n\nimport type { LoadedDataRange } from './VariableHeightVirtualizer';\nimport { getDataIndex } from './utils';\n\ninterface VirtualizerItemCountParams {\n  /** The starting index requested by virtualizer. */\n  startIndex: number;\n  /** The ending index requested by virtualizer. */\n  endIndex: number;\n  /** The range of items currently loaded. */\n  loadedDataRange: LoadedDataRange;\n  /** Indicates if the data is currently being fetched. */\n  isDataFetching: boolean;\n\n  /** Ref to the container holding rendered items. */\n  itemContainerRef: RefObject<HTMLElement>;\n  /** The rendered children items as ReactNode. */\n  children: ReactNode;\n\n  /** The total number of items if known, or `null`/`undefined` for infinite mode. */\n  totalItemCount?: number | null;\n  /** Optional buffer to add to the count in infinite mode. */\n  buffer?: number;\n  /** Signal to reset the count in infinite mode. */\n  countResetSignal?: number;\n}\n\n/**\n * Determines the count of virtualized items in a list and whether the list is in infinite scrolling mode or not.\n *\n * @returns An object containing:\n * - `isInfiniteMode`: Whether the list is in infinite scrolling mode.\n * - `virtualizedCount`: The current count of virtualized items.\n *\n * NOTE: In finite mode, the count is based on `totalItemCount`.\n * NOTE: In infinite mode, the count is dynamically calculated based on loaded items and buffer.\n */\nexport default function useVirtualizerItemCount(params: VirtualizerItemCountParams): {\n  isInfiniteMode: boolean;\n  virtualizedCount: number;\n} {\n  const {\n    startIndex,\n    endIndex,\n    loadedDataRange,\n    isDataFetching,\n    totalItemCount,\n    buffer = 10,\n    countResetSignal,\n    itemContainerRef,\n    children\n  } = params;\n\n  const [virtualizedCount, setVirtualizedCount] = useState(totalItemCount || 0);\n\n  const isInfiniteMode = useMemo(\n    () => totalItemCount === null || totalItemCount === undefined,\n    [totalItemCount]\n  );\n\n  useLayoutEffect(() => {\n    if (!isInfiniteMode) {\n      setVirtualizedCount(totalItemCount ?? 0);\n    }\n  }, [totalItemCount, isInfiniteMode]);\n\n  useLayoutEffect(() => {\n    if (isInfiniteMode) {\n      setVirtualizedCount(0);\n    }\n  }, [countResetSignal, isInfiniteMode]);\n\n  // Calculating count based on loaded items for infinite scrolling\n  useEffect(() => {\n    if (!isInfiniteMode || !endIndex || !loadedDataRange.endIndex || isDataFetching) return;\n\n    const items = itemContainerRef.current?.children;\n    if (!items?.length) {\n      setVirtualizedCount(0);\n      return;\n    }\n\n    const lastItemDataIndex = getDataIndex(items[items.length - 1]) ?? -1;\n\n    const hasMoreResults =\n      loadedDataRange.startIndex === startIndex &&\n      loadedDataRange.endIndex === endIndex &&\n      lastItemDataIndex === endIndex;\n\n    if (!hasMoreResults && Number.isInteger(lastItemDataIndex)) {\n      setVirtualizedCount(lastItemDataIndex + 1);\n      return;\n    }\n\n    const countWithBuffer = loadedDataRange.endIndex + 1 + buffer;\n    if (hasMoreResults && countWithBuffer > virtualizedCount) {\n      setVirtualizedCount(countWithBuffer);\n    }\n  }, [\n    isDataFetching,\n    children,\n    isInfiniteMode,\n    loadedDataRange,\n    virtualizedCount,\n    itemContainerRef,\n    endIndex\n  ]);\n\n  return {\n    isInfiniteMode,\n    virtualizedCount\n  };\n}\n"]}

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/utils.d.ts

@@ -0,0 +1,112 @@
+import type { RefObject } from 'react';
+import type { ItemsHeight } from './VariableHeightVirtualizer';
+interface GetVirtualizedPaginationIndicesParams {
+    /** Current vertical scroll offset of the container. */
+    scrollTop: number;
+    /** Ref to the scrolling container element */
+    containerRef: RefObject<HTMLElement>;
+    /** Ref to the container holding the list items */
+    itemContainerRef: RefObject<HTMLElement>;
+    /** Total number of items. */
+    totalItemCount: number;
+    /** Mapping of item indices and their actual height. */
+    itemsHeight: ItemsHeight;
+    /** Default height for items if not measured. */
+    defaultItemHeight: number;
+    /** Number of extra items to render above and below the visible viewport for smooth scrolling. */
+    buffer: number;
+    /** Maximum allowed end index (exclusive). */
+    endIndexLimit: number;
+    /** If true, allows indices to exceed totalCount for infinite scrolling by including buffer. */
+    isInfiniteMode?: boolean;
+}
+/**
+ * Calculates the start and end indices for virtualized pagination in a variable-height list.
+ *
+ * @returns {{ startIndex: number, endIndex: number }} Object containing the calculated start and end indices for rendering (inclusive both indices).
+ */
+export declare const getVirtualizedPaginationIndices: (param: GetVirtualizedPaginationIndicesParams) => {
+    startIndex: number;
+    endIndex: number;
+};
+/**
+ * Calculates the total buffer height for a list of items, using their individual heights if available,
+ * or a default height otherwise.
+ *
+ * @param totalItemCount - The total number of items in the list.
+ * @param itemsHeight - An object or array containing the heights of individual items, indexed by item position.
+ * @param defaultItemHeight - The default height to use for items whose height is not specified in `itemsHeight`.
+ * @returns The sum of all item heights, using the default height for any missing values.
+ */
+export declare const calculateTotalBufferHeight: (totalItemCount: number, itemsHeight: ItemsHeight, defaultItemHeight: number) => number;
+/**
+ * Returns a CSS-compatible max-height value based on the input.
+ *
+ * @param viewMaxHeight - The maximum height value, which can be a number (pixels), a string (CSS value), or `null`.
+ * @returns A string representing the CSS max-height value.
+ */
+export declare const getMaxHeight: (viewMaxHeight: number | string | null) => string;
+/**
+ * Calculates the vertical offset for a given item index in a list with variable item heights.
+ *
+ * @param index - The index of the item for which to calculate the offset.
+ * @param itemsHeight - Mapping of item indices and their actual height.
+ * @param defaultItemHeight - The default height to use for items not present in the cache.
+ * @returns The total offset (in pixels) from the top of the list to the specified index.
+ */
+export declare const getOffsetForIndex: (index: number, itemsHeight: ItemsHeight, defaultItemHeight: number) => number;
+/**
+ * Determines whether the viewable area of a virtualized list is not fully filled with rendered items.
+ *
+ * @param totalItemCount - The total number of items that should be rendered.
+ * @param itemContainer - The HTML element containing the rendered items.
+ * @param parentContainer - The parent HTML element that contains the items and possibly the header.
+ * @param renderHeader - Indicates whether a header is rendered at the top of the parent container.
+ * @returns `true` if the view is not filled with all items, `false` otherwise.
+ */
+export declare const isViewNotFilled: (totalItemCount: number, itemContainer: HTMLElement, parentContainer: HTMLElement, renderHeader: boolean) => boolean;
+/**
+ * Retrieves the numeric data index from the `data-index` attribute of a given Element.
+ *
+ * @param element - The Element from which to extract the data index.
+ * @returns The parsed integer value of the `data-index` attribute, or `null` if the attribute is not present.
+ */
+export declare const getDataIndex: (element: Element) => number | null;
+/**
+ * Calculates and returns an object containing the heights of items whose heights have changed
+ * compared to their previous values.
+ *
+ * @param itemContainer - The container HTMLElement whose child nodes represent items to measure.
+ * @param itemsHeight - An object mapping item indices to their measured heights.
+ * @param defaultItemHeight - The default height to use for items not present in `itemsHeight`.
+ * @returns An object mapping item indices to their new heights for items whose heights have changed.
+ */
+export declare function getChangedItemsHeight(itemContainer: HTMLElement, itemsHeight: ItemsHeight, defaultItemHeight: number): ItemsHeight;
+/**
+ * Calculates the cumulative change in item heights between two sets of item height data,
+ * for a range of items starting from `startIndex` up to (but not including) `previousFirstItemDataIndex`.
+ *
+ * This function compares the current heights (`itemsHeight`) with the previous heights (`previousItemsHeight`)
+ * for each item in the specified range, using `defaultItemHeight` as a fallback if a previous height is missing.
+ * The result is the sum of the differences in height for all items in the range.
+ *
+ * @param startIndex - The index at which to start calculating the cumulative height change.
+ * @param previousFirstItemDataIndex - The index up to which to calculate (exclusive). If `null` or less than or equal to 0, returns 0.
+ * @param itemsHeight - An object mapping item indices to their measured heights.
+ * @param previousItemsHeight - An object mapping item indices of previously rendered items to their heights.
+ * @param defaultItemHeight - The default height to use if a previous height is not available.
+ * @returns The cumulative change in item heights for the specified range, or 0 if the result is not finite.
+ */
+export declare const calculateCumulativeItemSizeChange: (startIndex: number, previousFirstItemDataIndex: number | null, itemsHeight: ItemsHeight, previousItemsHeight: ItemsHeight, defaultItemHeight: number) => number;
+/**
+ * Updates the position styles of child items within a container element to enable virtualized rendering.
+ * Sets the container's top offset and positions each child absolutely based on their calculated heights.
+ *
+ * @param itemContainer - The HTML element containing the list items to be positioned.
+ * @param itemsHeight - An object mapping item indices to their measured heights.
+ * @param defaultItemHeight - The default height to use for items without a specified height.
+ * @returns The total height of all items within the container, rounded down to the nearest integer.
+ */
+export declare const updateItemPositionStyles: (itemContainer: HTMLElement, itemsHeight: ItemsHeight, defaultItemHeight: number) => number;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../Core/Components/Virtualise/VariableHeightVirtualizer/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE/D,UAAU,qCAAqC;IAC7C,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,6CAA6C;IAC7C,YAAY,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;IACrC,kDAAkD;IAClD,gBAAgB,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;IAEzC,6BAA6B;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,WAAW,EAAE,WAAW,CAAC;IACzB,gDAAgD;IAChD,iBAAiB,EAAE,MAAM,CAAC;IAE1B,iGAAiG;IACjG,MAAM,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,aAAa,EAAE,MAAM,CAAC;IACtB,+FAA+F;IAC/F,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,GAC1C,OAAO,qCAAqC,KAC3C;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAgDxC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,GACrC,gBAAgB,MAAM,EACtB,aAAa,WAAW,EACxB,mBAAmB,MAAM,KACxB,MAOF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,eAAe,MAAM,GAAG,MAAM,GAAG,IAAI,KAAG,MAGpE,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,MAAM,EACb,aAAa,WAAW,EACxB,mBAAmB,MAAM,KACxB,MAOF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAC1B,gBAAgB,MAAM,EACtB,eAAe,WAAW,EAC1B,iBAAiB,WAAW,EAC5B,cAAc,OAAO,KACpB,OA2BF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,OAAO,KAAG,MAAM,GAAG,IAKxD,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,WAAW,EAC1B,WAAW,EAAE,WAAW,EACxB,iBAAiB,EAAE,MAAM,GACxB,WAAW,CAkBb;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iCAAiC,GAC5C,YAAY,MAAM,EAClB,4BAA4B,MAAM,GAAG,IAAI,EACzC,aAAa,WAAW,EACxB,qBAAqB,WAAW,EAChC,mBAAmB,MAAM,KACxB,MAiBF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,GACnC,eAAe,WAAW,EAC1B,aAAa,WAAW,EACxB,mBAAmB,MAAM,KACxB,MAwBF,CAAC"}

package/lib/Core/Components/Virtualise/VariableHeightVirtualizer/utils.js

@@ -0,0 +1,213 @@
+import { getScrollbarWidth } from 'pega-repeating-structures-core';
+/**
+ * Calculates the start and end indices for virtualized pagination in a variable-height list.
+ *
+ * @returns {{ startIndex: number, endIndex: number }} Object containing the calculated start and end indices for rendering (inclusive both indices).
+ */
+export const getVirtualizedPaginationIndices = (param) => {
+    const { totalItemCount, buffer, itemContainerRef, scrollTop, containerRef, itemsHeight, defaultItemHeight, endIndexLimit, isInfiniteMode } = param;
+    const minimumItemsToFetchOnTop = buffer * 4;
+    if (totalItemCount === 0 || itemContainerRef.current?.childElementCount === 0) {
+        return { startIndex: 0, endIndex: minimumItemsToFetchOnTop };
+    }
+    const viewportHeight = containerRef.current?.clientHeight || 0;
+    // Find the first visible item index for the current scroll position
+    let aboveTheFoldItemsHeight = 0;
+    let visibleStartIndex = 0;
+    while (visibleStartIndex < totalItemCount &&
+        aboveTheFoldItemsHeight + (itemsHeight[visibleStartIndex] ?? defaultItemHeight) < scrollTop) {
+        aboveTheFoldItemsHeight += itemsHeight[visibleStartIndex] ?? defaultItemHeight;
+        visibleStartIndex += 1;
+    }
+    // Find the last visible item index for the current scroll position
+    let inViewItemsHeight = 0;
+    let visibleEndIndex = visibleStartIndex;
+    while (visibleEndIndex < totalItemCount && inViewItemsHeight < viewportHeight) {
+        inViewItemsHeight += itemsHeight[visibleEndIndex] ?? defaultItemHeight;
+        visibleEndIndex += 1;
+    }
+    const startIndex = Math.max(0, visibleStartIndex - buffer);
+    let endIndex = Math.min(visibleEndIndex + buffer, endIndexLimit - 1);
+    if (isInfiniteMode) {
+        endIndex = Math.max(endIndex, minimumItemsToFetchOnTop);
+    }
+    else {
+        // In cases where the count is very less due to filters, we would fetch more items to avoid unnecessary API calls if the count after the filter removed is more
+        endIndex = Math.max(Math.min(totalItemCount - 1, endIndex), minimumItemsToFetchOnTop);
+    }
+    return { startIndex, endIndex };
+};
+/**
+ * Calculates the total buffer height for a list of items, using their individual heights if available,
+ * or a default height otherwise.
+ *
+ * @param totalItemCount - The total number of items in the list.
+ * @param itemsHeight - An object or array containing the heights of individual items, indexed by item position.
+ * @param defaultItemHeight - The default height to use for items whose height is not specified in `itemsHeight`.
+ * @returns The sum of all item heights, using the default height for any missing values.
+ */
+export const calculateTotalBufferHeight = (totalItemCount, itemsHeight, defaultItemHeight) => {
+    let totalBufferHeight = 0;
+    for (let i = 0; i < totalItemCount; i += 1) {
+        totalBufferHeight += itemsHeight[i] || defaultItemHeight;
+    }
+    return totalBufferHeight;
+};
+/**
+ * Returns a CSS-compatible max-height value based on the input.
+ *
+ * @param viewMaxHeight - The maximum height value, which can be a number (pixels), a string (CSS value), or `null`.
+ * @returns A string representing the CSS max-height value.
+ */
+export const getMaxHeight = (viewMaxHeight) => {
+    if (!viewMaxHeight)
+        return 'none';
+    return typeof viewMaxHeight === 'number' ? `${viewMaxHeight}px` : viewMaxHeight;
+};
+/**
+ * Calculates the vertical offset for a given item index in a list with variable item heights.
+ *
+ * @param index - The index of the item for which to calculate the offset.
+ * @param itemsHeight - Mapping of item indices and their actual height.
+ * @param defaultItemHeight - The default height to use for items not present in the cache.
+ * @returns The total offset (in pixels) from the top of the list to the specified index.
+ */
+export const getOffsetForIndex = (index, itemsHeight, defaultItemHeight) => {
+    let offset = 0;
+    for (let i = 0; i < index; i += 1) {
+        offset += itemsHeight[i] ?? defaultItemHeight;
+    }
+    return offset;
+};
+/**
+ * Determines whether the viewable area of a virtualized list is not fully filled with rendered items.
+ *
+ * @param totalItemCount - The total number of items that should be rendered.
+ * @param itemContainer - The HTML element containing the rendered items.
+ * @param parentContainer - The parent HTML element that contains the items and possibly the header.
+ * @param renderHeader - Indicates whether a header is rendered at the top of the parent container.
+ * @returns `true` if the view is not filled with all items, `false` otherwise.
+ */
+export const isViewNotFilled = (totalItemCount, itemContainer, parentContainer, renderHeader) => {
+    const parentContainerPosition = parentContainer.getBoundingClientRect();
+    let headerHeight = 0;
+    if (renderHeader && parentContainer.childElementCount > 1) {
+        const firstChild = parentContainer.children[0];
+        if (firstChild instanceof HTMLElement) {
+            headerHeight = firstChild.offsetHeight;
+        }
+    }
+    const scrollbarWidth = getScrollbarWidth();
+    const items = Array.from(itemContainer.children).filter((el) => el instanceof HTMLElement);
+    if (!items.length && !totalItemCount)
+        return false;
+    if (!items.length && totalItemCount)
+        return true;
+    return (!!totalItemCount &&
+        items.length !== totalItemCount &&
+        (Math.floor(items[items.length - 1].getBoundingClientRect().bottom) <
+            Math.floor(parentContainerPosition.bottom - scrollbarWidth) ||
+            Math.floor(items[0].getBoundingClientRect().top) >
+                Math.floor(parentContainerPosition.top + headerHeight) ||
+            items.length === 0));
+};
+/**
+ * Retrieves the numeric data index from the `data-index` attribute of a given Element.
+ *
+ * @param element - The Element from which to extract the data index.
+ * @returns The parsed integer value of the `data-index` attribute, or `null` if the attribute is not present.
+ */
+export const getDataIndex = (element) => {
+    const dataIndexStr = element?.getAttribute('data-index');
+    if (!dataIndexStr)
+        return null;
+    const parsedDataIndex = parseInt(dataIndexStr, 10);
+    return Number.isNaN(parsedDataIndex) ? null : parsedDataIndex;
+};
+/**
+ * Calculates and returns an object containing the heights of items whose heights have changed
+ * compared to their previous values.
+ *
+ * @param itemContainer - The container HTMLElement whose child nodes represent items to measure.
+ * @param itemsHeight - An object mapping item indices to their measured heights.
+ * @param defaultItemHeight - The default height to use for items not present in `itemsHeight`.
+ * @returns An object mapping item indices to their new heights for items whose heights have changed.
+ */
+export function getChangedItemsHeight(itemContainer, itemsHeight, defaultItemHeight) {
+    if (!itemContainer)
+        return {};
+    const newHeights = {};
+    const nodes = Array.from(itemContainer.children);
+    nodes.forEach(node => {
+        const itemDataIndex = getDataIndex(node);
+        if (itemDataIndex === null)
+            return;
+        const measuredHeight = node.getBoundingClientRect().height;
+        const prevHeight = itemsHeight[itemDataIndex] ?? defaultItemHeight;
+        if (measuredHeight !== prevHeight) {
+            newHeights[itemDataIndex] = measuredHeight;
+        }
+    });
+    return newHeights;
+}
+/**
+ * Calculates the cumulative change in item heights between two sets of item height data,
+ * for a range of items starting from `startIndex` up to (but not including) `previousFirstItemDataIndex`.
+ *
+ * This function compares the current heights (`itemsHeight`) with the previous heights (`previousItemsHeight`)
+ * for each item in the specified range, using `defaultItemHeight` as a fallback if a previous height is missing.
+ * The result is the sum of the differences in height for all items in the range.
+ *
+ * @param startIndex - The index at which to start calculating the cumulative height change.
+ * @param previousFirstItemDataIndex - The index up to which to calculate (exclusive). If `null` or less than or equal to 0, returns 0.
+ * @param itemsHeight - An object mapping item indices to their measured heights.
+ * @param previousItemsHeight - An object mapping item indices of previously rendered items to their heights.
+ * @param defaultItemHeight - The default height to use if a previous height is not available.
+ * @returns The cumulative change in item heights for the specified range, or 0 if the result is not finite.
+ */
+export const calculateCumulativeItemSizeChange = (startIndex, previousFirstItemDataIndex, itemsHeight, previousItemsHeight, defaultItemHeight) => {
+    if (previousFirstItemDataIndex === null || previousFirstItemDataIndex <= 0) {
+        return 0;
+    }
+    let delta = 0;
+    for (let i = startIndex; i < previousFirstItemDataIndex; i += 1) {
+        const actualHeight = itemsHeight[i];
+        const previousHeight = previousItemsHeight[i] ?? defaultItemHeight;
+        if (actualHeight !== null && actualHeight !== undefined) {
+            delta += actualHeight - previousHeight;
+        }
+    }
+    return Number.isFinite(delta) ? delta : 0;
+};
+/**
+ * Updates the position styles of child items within a container element to enable virtualized rendering.
+ * Sets the container's top offset and positions each child absolutely based on their calculated heights.
+ *
+ * @param itemContainer - The HTML element containing the list items to be positioned.
+ * @param itemsHeight - An object mapping item indices to their measured heights.
+ * @param defaultItemHeight - The default height to use for items without a specified height.
+ * @returns The total height of all items within the container, rounded down to the nearest integer.
+ */
+export const updateItemPositionStyles = (itemContainer, itemsHeight, defaultItemHeight) => {
+    const items = itemContainer.children;
+    if (!items?.length) {
+        return 0;
+    }
+    const firstItemDataIndex = getDataIndex(items[0]);
+    if (firstItemDataIndex === null)
+        return 0;
+    const offset = getOffsetForIndex(firstItemDataIndex, itemsHeight, defaultItemHeight);
+    itemContainer.style.top = `${offset}px`;
+    let itemContainerCurrentHeight = 0;
+    let currentItemIndex = firstItemDataIndex;
+    Array.from(items).forEach((item) => {
+        if (!(item instanceof HTMLElement))
+            return;
+        item.style.position = 'absolute';
+        item.style.top = `${itemContainerCurrentHeight}px`;
+        itemContainerCurrentHeight += itemsHeight[currentItemIndex] ?? defaultItemHeight;
+        currentItemIndex += 1;
+    });
+    return Math.floor(itemContainerCurrentHeight);
+};
+//# sourceMappingURL=utils.js.map