Function createCachedBounds

lib/core/createCachedBounds.ts:4–70

({
  itemCount,
  itemProps,
  itemSize
}: {
  itemCount: number;
  itemProps: Props;
  itemSize: number | SizeFunction<Props>;
})

import type { Bounds, CachedBounds, SizeFunction } from "./types";

export function createCachedBounds<Props extends object>({
  itemCount,
  itemProps,
  itemSize
}: {
  itemCount: number;
  itemProps: Props;
  itemSize: number | SizeFunction<Props>;
}): CachedBounds {
  const cache = new Map<number, Bounds>();

  return {
    itemSize: typeof itemSize === "number" ? itemSize : undefined,
    get(index: number) {
      assert(index < itemCount, `Invalid index ${index}`);

      if (typeof itemSize === "number") {
        assert(index >= 0, `Invalid index ${index}`);
        let bounds = cache.get(index);
        if (bounds === undefined) {
          bounds = { size: itemSize, scrollOffset: index * itemSize };
          cache.set(index, bounds);
        }
        return bounds;
      }

      while (cache.size - 1 < index) {
        const currentIndex = cache.size;

        const size = itemSize(currentIndex, itemProps);

        if (currentIndex === 0) {
          cache.set(currentIndex, {
            size,
            scrollOffset: 0
          });
        } else {
          const previousRowBounds = cache.get(currentIndex - 1);
          assert(
            previousRowBounds !== undefined,
            `Unexpected bounds cache miss for index ${index}`
          );

          cache.set(currentIndex, {
            scrollOffset:
              previousRowBounds.scrollOffset + previousRowBounds.size,
            size
          });
        }
      }

      const bounds = cache.get(index);
      assert(
        bounds !== undefined,
        `Unexpected bounds cache miss for index ${index}`
      );

      return bounds;