@react-native/virtualized-lists 0.72.0 → 0.72.1

package/Lists/__tests__/ViewabilityHelper-test.js

@@ -1,444 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @format
- * @oncall react_native
- */
-
-'use strict';
-
-const ViewabilityHelper = require('../ViewabilityHelper');
-
-let rowFrames;
-let data;
-const props = {
-  data,
-  getItemCount: () => data.length,
-};
-function getFrameMetrics(index: number) {
-  const frame = rowFrames[data[index].key];
-  return {length: frame.height, offset: frame.y};
-}
-function createViewToken(index: number, isViewable: boolean) {
-  return {key: data[index].key, isViewable};
-}
-
-describe('computeViewableItems', function () {
-  it('returns all 4 entirely visible rows as viewable', function () {
-    const helper = new ViewabilityHelper({
-      viewAreaCoveragePercentThreshold: 50,
-    });
-    rowFrames = {
-      a: {y: 0, height: 50},
-      b: {y: 50, height: 50},
-      c: {y: 100, height: 50},
-      d: {y: 150, height: 50},
-    };
-    data = [{key: 'a'}, {key: 'b'}, {key: 'c'}, {key: 'd'}];
-    expect(helper.computeViewableItems(props, 0, 200, getFrameMetrics)).toEqual(
-      [0, 1, 2, 3],
-    );
-  });
-
-  it('returns top 2 rows as viewable (1. entirely visible and 2. majority)', function () {
-    const helper = new ViewabilityHelper({
-      viewAreaCoveragePercentThreshold: 50,
-    });
-    rowFrames = {
-      a: {y: 0, height: 50},
-      b: {y: 50, height: 150},
-      c: {y: 200, height: 50},
-      d: {y: 250, height: 50},
-    };
-    data = [{key: 'a'}, {key: 'b'}, {key: 'c'}, {key: 'd'}];
-    expect(helper.computeViewableItems(props, 0, 200, getFrameMetrics)).toEqual(
-      [0, 1],
-    );
-  });
-
-  it('returns only 2nd row as viewable (majority)', function () {
-    const helper = new ViewabilityHelper({
-      viewAreaCoveragePercentThreshold: 50,
-    });
-    rowFrames = {
-      a: {y: 0, height: 50},
-      b: {y: 50, height: 150},
-      c: {y: 200, height: 50},
-      d: {y: 250, height: 50},
-    };
-    data = [{key: 'a'}, {key: 'b'}, {key: 'c'}, {key: 'd'}];
-    expect(
-      helper.computeViewableItems(props, 25, 200, getFrameMetrics),
-    ).toEqual([1]);
-  });
-
-  it('handles empty input', function () {
-    const helper = new ViewabilityHelper({
-      viewAreaCoveragePercentThreshold: 50,
-    });
-    rowFrames = {};
-    data = [];
-    expect(helper.computeViewableItems(props, 0, 200, getFrameMetrics)).toEqual(
-      [],
-    );
-  });
-
-  it('handles different view area coverage percent thresholds', function () {
-    rowFrames = {
-      a: {y: 0, height: 50},
-      b: {y: 50, height: 150},
-      c: {y: 200, height: 500},
-      d: {y: 700, height: 50},
-    };
-    data = [{key: 'a'}, {key: 'b'}, {key: 'c'}, {key: 'd'}];
-
-    let helper = new ViewabilityHelper({viewAreaCoveragePercentThreshold: 0});
-    expect(helper.computeViewableItems(props, 0, 50, getFrameMetrics)).toEqual([
-      0,
-    ]);
-    expect(helper.computeViewableItems(props, 1, 50, getFrameMetrics)).toEqual([
-      0, 1,
-    ]);
-    expect(
-      helper.computeViewableItems(props, 199, 50, getFrameMetrics),
-    ).toEqual([1, 2]);
-    expect(
-      helper.computeViewableItems(props, 250, 50, getFrameMetrics),
-    ).toEqual([2]);
-
-    helper = new ViewabilityHelper({viewAreaCoveragePercentThreshold: 100});
-    expect(helper.computeViewableItems(props, 0, 200, getFrameMetrics)).toEqual(
-      [0, 1],
-    );
-    expect(helper.computeViewableItems(props, 1, 200, getFrameMetrics)).toEqual(
-      [1],
-    );
-    expect(
-      helper.computeViewableItems(props, 400, 200, getFrameMetrics),
-    ).toEqual([2]);
-    expect(
-      helper.computeViewableItems(props, 600, 200, getFrameMetrics),
-    ).toEqual([3]);
-
-    helper = new ViewabilityHelper({viewAreaCoveragePercentThreshold: 10});
-    expect(
-      helper.computeViewableItems(props, 30, 200, getFrameMetrics),
-    ).toEqual([0, 1, 2]);
-    expect(
-      helper.computeViewableItems(props, 31, 200, getFrameMetrics),
-    ).toEqual([1, 2]);
-  });
-
-  it('handles different item visible percent thresholds', function () {
-    rowFrames = {
-      a: {y: 0, height: 50},
-      b: {y: 50, height: 150},
-      c: {y: 200, height: 50},
-      d: {y: 250, height: 50},
-    };
-    data = [{key: 'a'}, {key: 'b'}, {key: 'c'}, {key: 'd'}];
-    let helper = new ViewabilityHelper({itemVisiblePercentThreshold: 0});
-    expect(helper.computeViewableItems(props, 0, 50, getFrameMetrics)).toEqual([
-      0,
-    ]);
-    expect(helper.computeViewableItems(props, 1, 50, getFrameMetrics)).toEqual([
-      0, 1,
-    ]);
-
-    helper = new ViewabilityHelper({itemVisiblePercentThreshold: 100});
-    expect(helper.computeViewableItems(props, 0, 250, getFrameMetrics)).toEqual(
-      [0, 1, 2],
-    );
-    expect(helper.computeViewableItems(props, 1, 250, getFrameMetrics)).toEqual(
-      [1, 2],
-    );
-
-    helper = new ViewabilityHelper({itemVisiblePercentThreshold: 10});
-    expect(
-      helper.computeViewableItems(props, 184, 20, getFrameMetrics),
-    ).toEqual([1]);
-    expect(
-      helper.computeViewableItems(props, 185, 20, getFrameMetrics),
-    ).toEqual([1, 2]);
-    expect(
-      helper.computeViewableItems(props, 186, 20, getFrameMetrics),
-    ).toEqual([2]);
-  });
-});
-
-describe('onUpdate', function () {
-  it('returns 1 visible row as viewable then scrolls away', function () {
-    const helper = new ViewabilityHelper();
-    rowFrames = {
-      a: {y: 0, height: 50},
-    };
-    data = [{key: 'a'}];
-    const onViewableItemsChanged = jest.fn();
-    helper.onUpdate(
-      props,
-      0,
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    expect(onViewableItemsChanged.mock.calls.length).toBe(1);
-    expect(onViewableItemsChanged.mock.calls[0][0]).toEqual({
-      changed: [{isViewable: true, key: 'a'}],
-      viewabilityConfig: {viewAreaCoveragePercentThreshold: 0},
-      viewableItems: [{isViewable: true, key: 'a'}],
-    });
-    helper.onUpdate(
-      props,
-      0,
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    expect(onViewableItemsChanged.mock.calls.length).toBe(1); // nothing changed!
-    helper.onUpdate(
-      props,
-      100,
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    expect(onViewableItemsChanged.mock.calls.length).toBe(2);
-    expect(onViewableItemsChanged.mock.calls[1][0]).toEqual({
-      changed: [{isViewable: false, key: 'a'}],
-      viewabilityConfig: {viewAreaCoveragePercentThreshold: 0},
-      viewableItems: [],
-    });
-  });
-
-  it('returns 1st visible row then 1st and 2nd then just 2nd', function () {
-    const helper = new ViewabilityHelper();
-    rowFrames = {
-      a: {y: 0, height: 200},
-      b: {y: 200, height: 200},
-    };
-    data = [{key: 'a'}, {key: 'b'}];
-    const onViewableItemsChanged = jest.fn();
-    helper.onUpdate(
-      props,
-      0,
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    expect(onViewableItemsChanged.mock.calls.length).toBe(1);
-    expect(onViewableItemsChanged.mock.calls[0][0]).toEqual({
-      changed: [{isViewable: true, key: 'a'}],
-      viewabilityConfig: {viewAreaCoveragePercentThreshold: 0},
-      viewableItems: [{isViewable: true, key: 'a'}],
-    });
-    helper.onUpdate(
-      props,
-      100,
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    expect(onViewableItemsChanged.mock.calls.length).toBe(2);
-    // Both visible with 100px overlap each
-    expect(onViewableItemsChanged.mock.calls[1][0]).toEqual({
-      changed: [{isViewable: true, key: 'b'}],
-      viewabilityConfig: {viewAreaCoveragePercentThreshold: 0},
-      viewableItems: [
-        {isViewable: true, key: 'a'},
-        {isViewable: true, key: 'b'},
-      ],
-    });
-    helper.onUpdate(
-      props,
-      200,
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    expect(onViewableItemsChanged.mock.calls.length).toBe(3);
-    expect(onViewableItemsChanged.mock.calls[2][0]).toEqual({
-      changed: [{isViewable: false, key: 'a'}],
-      viewabilityConfig: {viewAreaCoveragePercentThreshold: 0},
-      viewableItems: [{isViewable: true, key: 'b'}],
-    });
-  });
-
-  it('minimumViewTime delays callback', function () {
-    const helper = new ViewabilityHelper({
-      minimumViewTime: 350,
-      viewAreaCoveragePercentThreshold: 0,
-    });
-    rowFrames = {
-      a: {y: 0, height: 200},
-      b: {y: 200, height: 200},
-    };
-    data = [{key: 'a'}, {key: 'b'}];
-    const onViewableItemsChanged = jest.fn();
-    helper.onUpdate(
-      props,
-      0,
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    expect(onViewableItemsChanged).not.toBeCalled();
-
-    jest.runAllTimers();
-
-    expect(onViewableItemsChanged.mock.calls.length).toBe(1);
-    expect(onViewableItemsChanged.mock.calls[0][0]).toEqual({
-      changed: [{isViewable: true, key: 'a'}],
-      viewabilityConfig: {
-        minimumViewTime: 350,
-        viewAreaCoveragePercentThreshold: 0,
-      },
-      viewableItems: [{isViewable: true, key: 'a'}],
-    });
-  });
-
-  it('minimumViewTime skips briefly visible items', function () {
-    const helper = new ViewabilityHelper({
-      minimumViewTime: 350,
-      viewAreaCoveragePercentThreshold: 0,
-    });
-    rowFrames = {
-      a: {y: 0, height: 250},
-      b: {y: 250, height: 200},
-    };
-    data = [{key: 'a'}, {key: 'b'}];
-    const onViewableItemsChanged = jest.fn();
-    helper.onUpdate(
-      props,
-      0,
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    helper.onUpdate(
-      props,
-      300, // scroll past item 'a'
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-
-    jest.runAllTimers();
-
-    expect(onViewableItemsChanged.mock.calls.length).toBe(1);
-    expect(onViewableItemsChanged.mock.calls[0][0]).toEqual({
-      changed: [{isViewable: true, key: 'b'}],
-      viewabilityConfig: {
-        minimumViewTime: 350,
-        viewAreaCoveragePercentThreshold: 0,
-      },
-      viewableItems: [{isViewable: true, key: 'b'}],
-    });
-  });
-
-  it('waitForInteraction blocks callback until interaction', function () {
-    const helper = new ViewabilityHelper({
-      waitForInteraction: true,
-      viewAreaCoveragePercentThreshold: 0,
-    });
-    rowFrames = {
-      a: {y: 0, height: 200},
-      b: {y: 200, height: 200},
-    };
-    data = [{key: 'a'}, {key: 'b'}];
-    const onViewableItemsChanged = jest.fn();
-    helper.onUpdate(
-      props,
-      0,
-      100,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    expect(onViewableItemsChanged).not.toBeCalled();
-
-    helper.recordInteraction();
-
-    helper.onUpdate(
-      props,
-      20,
-      100,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    expect(onViewableItemsChanged.mock.calls.length).toBe(1);
-    expect(onViewableItemsChanged.mock.calls[0][0]).toEqual({
-      changed: [{isViewable: true, key: 'a'}],
-      viewabilityConfig: {
-        waitForInteraction: true,
-        viewAreaCoveragePercentThreshold: 0,
-      },
-      viewableItems: [{isViewable: true, key: 'a'}],
-    });
-  });
-
-  it('returns the right visible row after the underlying data changed', function () {
-    const helper = new ViewabilityHelper();
-    rowFrames = {
-      a: {y: 0, height: 200},
-      b: {y: 200, height: 200},
-    };
-    data = [{key: 'a'}, {key: 'b'}];
-    const onViewableItemsChanged = jest.fn();
-    helper.onUpdate(
-      props,
-      0,
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    expect(onViewableItemsChanged.mock.calls.length).toBe(1);
-    expect(onViewableItemsChanged.mock.calls[0][0]).toEqual({
-      changed: [{isViewable: true, key: 'a'}],
-      viewabilityConfig: {viewAreaCoveragePercentThreshold: 0},
-      viewableItems: [{isViewable: true, key: 'a'}],
-    });
-
-    // update data
-    rowFrames = {
-      c: {y: 0, height: 200},
-      a: {y: 200, height: 200},
-      b: {y: 400, height: 200},
-    };
-    data = [{key: 'c'}, {key: 'a'}, {key: 'b'}];
-
-    helper.resetViewableIndices();
-
-    helper.onUpdate(
-      props,
-      0,
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-
-    expect(onViewableItemsChanged.mock.calls.length).toBe(2);
-    expect(onViewableItemsChanged.mock.calls[1][0]).toEqual({
-      changed: [
-        {isViewable: true, key: 'c'},
-        {isViewable: false, key: 'a'},
-      ],
-      viewabilityConfig: {viewAreaCoveragePercentThreshold: 0},
-      viewableItems: [{isViewable: true, key: 'c'}],
-    });
-  });
-});

package/Lists/__tests__/VirtualizeUtils-test.js

@@ -1,108 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @format
- * @oncall react_native
- */
-
-'use strict';
-
-import {elementsThatOverlapOffsets, newRangeCount} from '../VirtualizeUtils';
-
-describe('newRangeCount', function () {
-  it('handles subset', function () {
-    expect(newRangeCount({first: 1, last: 4}, {first: 2, last: 3})).toBe(0);
-  });
-  it('handles forward disjoint set', function () {
-    expect(newRangeCount({first: 1, last: 4}, {first: 6, last: 9})).toBe(4);
-  });
-  it('handles reverse disjoint set', function () {
-    expect(newRangeCount({first: 6, last: 8}, {first: 1, last: 4})).toBe(4);
-  });
-  it('handles superset', function () {
-    expect(newRangeCount({first: 1, last: 4}, {first: 0, last: 5})).toBe(2);
-  });
-  it('handles end extension', function () {
-    expect(newRangeCount({first: 1, last: 4}, {first: 1, last: 8})).toBe(4);
-  });
-  it('handles front extension', function () {
-    expect(newRangeCount({first: 1, last: 4}, {first: 0, last: 4})).toBe(1);
-  });
-  it('handles forward intersect', function () {
-    expect(newRangeCount({first: 1, last: 4}, {first: 3, last: 6})).toBe(2);
-  });
-  it('handles reverse intersect', function () {
-    expect(newRangeCount({first: 3, last: 6}, {first: 1, last: 4})).toBe(2);
-  });
-});
-
-describe('elementsThatOverlapOffsets', function () {
-  it('handles fixed length', function () {
-    const offsets = [0, 250, 350, 450];
-    function getFrameMetrics(index: number) {
-      return {
-        length: 100,
-        offset: 100 * index,
-      };
-    }
-    expect(
-      elementsThatOverlapOffsets(offsets, fakeProps(100), getFrameMetrics, 1),
-    ).toEqual([0, 2, 3, 4]);
-  });
-  it('handles variable length', function () {
-    const offsets = [150, 250, 900];
-    const frames = [
-      {offset: 0, length: 50},
-      {offset: 50, length: 200},
-      {offset: 250, length: 600},
-      {offset: 850, length: 100},
-      {offset: 950, length: 150},
-    ];
-    expect(
-      elementsThatOverlapOffsets(
-        offsets,
-        fakeProps(frames.length),
-        ii => frames[ii],
-        1,
-      ),
-    ).toEqual([1, 1, 3]);
-  });
-  it('handles frame boundaries', function () {
-    const offsets = [0, 100, 200, 300];
-    function getFrameMetrics(index: number) {
-      return {
-        length: 100,
-        offset: 100 * index,
-      };
-    }
-    expect(
-      elementsThatOverlapOffsets(offsets, fakeProps(100), getFrameMetrics, 1),
-    ).toEqual([0, 0, 1, 2]);
-  });
-  it('handles out of bounds', function () {
-    const offsets = [-100, 150, 900];
-    const frames = [
-      {offset: 0, length: 50},
-      {offset: 50, length: 150},
-      {offset: 250, length: 100},
-    ];
-    expect(
-      elementsThatOverlapOffsets(
-        offsets,
-        fakeProps(frames.length),
-        ii => frames[ii],
-        1,
-      ),
-    ).toEqual([undefined, 1]);
-  });
-});
-
-function fakeProps(length) {
-  return {
-    data: new Array(length).fill({}),
-    getItemCount: () => length,
-  };
-}