react-native-windows 0.70.9 → 0.71.0-preview.2

package/Libraries/Lists/__tests__/SectionList-test.js

@@ -1,109 +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
- * @emails oncall+react_native
- */
-
-'use strict';
-
-import * as React from 'react';
-import ReactTestRenderer from 'react-test-renderer';
-
-import SectionList from '../SectionList';
-
-describe('SectionList', () => {
-  it('renders empty list', () => {
-    const component = ReactTestRenderer.create(
-      <SectionList
-        sections={[]}
-        renderItem={({item}) => <item v={item.key} />}
-      />,
-    );
-    expect(component).toMatchSnapshot();
-  });
-  it('rendering empty section headers is fine', () => {
-    const component = ReactTestRenderer.create(
-      <SectionList
-        sections={[{key: 's1', data: [{key: 'i1'}, {key: 'i2'}]}]}
-        renderItem={({item}) => <item v={item.key} />}
-        renderSectionHeader={() => null}
-      />,
-    );
-    expect(component).toMatchSnapshot();
-  });
-  it('renders all the bells and whistles', () => {
-    const component = ReactTestRenderer.create(
-      <SectionList
-        initialNumToRender={Infinity}
-        ItemSeparatorComponent={props => (
-          <defaultItemSeparator v={propStr(props)} />
-        )}
-        ListEmptyComponent={props => <empty v={propStr(props)} />}
-        ListFooterComponent={props => <footer v={propStr(props)} />}
-        ListHeaderComponent={props => <header v={propStr(props)} />}
-        SectionSeparatorComponent={props => (
-          <sectionSeparator v={propStr(props)} />
-        )}
-        sections={[
-          {
-            renderItem: props => <itemForSection1 v={propStr(props)} />,
-            key: 's1',
-            keyExtractor: (item, index) => item.id,
-            ItemSeparatorComponent: props => (
-              <itemSeparatorForSection1 v={propStr(props)} />
-            ),
-            data: [{id: 'i1s1'}, {id: 'i2s1'}],
-          },
-          {
-            key: 's2',
-            data: [{key: 'i1s2'}, {key: 'i2s2'}],
-          },
-          {
-            key: 's3',
-            data: [{key: 'i1s3'}, {key: 'i2s3'}],
-          },
-        ]}
-        refreshing={false}
-        onRefresh={jest.fn()}
-        renderItem={props => <defaultItem v={propStr(props)} />}
-        renderSectionHeader={props => <sectionHeader v={propStr(props)} />}
-        renderSectionFooter={props => <sectionFooter v={propStr(props)} />}
-      />,
-    );
-    expect(component).toMatchSnapshot();
-  });
-  it('renders a footer when there is no data', () => {
-    const component = ReactTestRenderer.create(
-      <SectionList
-        sections={[{key: 's1', data: []}]}
-        renderItem={({item}) => <item v={item.key} />}
-        renderSectionHeader={props => <sectionHeader v={propStr(props)} />}
-        renderSectionFooter={props => <sectionFooter v={propStr(props)} />}
-      />,
-    );
-    expect(component).toMatchSnapshot();
-  });
-  it('renders a footer when there is no data and no header', () => {
-    const component = ReactTestRenderer.create(
-      <SectionList
-        sections={[{key: 's1', data: []}]}
-        renderItem={({item}) => <item v={item.key} />}
-        renderSectionFooter={props => <sectionFooter v={propStr(props)} />}
-      />,
-    );
-    expect(component).toMatchSnapshot();
-  });
-});
-
-function propStr(props) {
-  return Object.keys(props)
-    .map(k => {
-      const propObj = props[k] || {};
-      return `${k}:${propObj.key || propObj.id || props[k]}`;
-    })
-    .join(',');
-}

package/Libraries/Lists/__tests__/ViewabilityHelper-test.js

@@ -1,440 +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
- * @emails oncall+react_native
- */
-
-'use strict';
-
-const ViewabilityHelper = require('../ViewabilityHelper');
-
-let rowFrames;
-let data;
-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(data.length, 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(data.length, 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(data.length, 25, 200, getFrameMetrics),
-    ).toEqual([1]);
-  });
-
-  it('handles empty input', function () {
-    const helper = new ViewabilityHelper({
-      viewAreaCoveragePercentThreshold: 50,
-    });
-    rowFrames = {};
-    data = [];
-    expect(
-      helper.computeViewableItems(data.length, 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(data.length, 0, 50, getFrameMetrics),
-    ).toEqual([0]);
-    expect(
-      helper.computeViewableItems(data.length, 1, 50, getFrameMetrics),
-    ).toEqual([0, 1]);
-    expect(
-      helper.computeViewableItems(data.length, 199, 50, getFrameMetrics),
-    ).toEqual([1, 2]);
-    expect(
-      helper.computeViewableItems(data.length, 250, 50, getFrameMetrics),
-    ).toEqual([2]);
-
-    helper = new ViewabilityHelper({viewAreaCoveragePercentThreshold: 100});
-    expect(
-      helper.computeViewableItems(data.length, 0, 200, getFrameMetrics),
-    ).toEqual([0, 1]);
-    expect(
-      helper.computeViewableItems(data.length, 1, 200, getFrameMetrics),
-    ).toEqual([1]);
-    expect(
-      helper.computeViewableItems(data.length, 400, 200, getFrameMetrics),
-    ).toEqual([2]);
-    expect(
-      helper.computeViewableItems(data.length, 600, 200, getFrameMetrics),
-    ).toEqual([3]);
-
-    helper = new ViewabilityHelper({viewAreaCoveragePercentThreshold: 10});
-    expect(
-      helper.computeViewableItems(data.length, 30, 200, getFrameMetrics),
-    ).toEqual([0, 1, 2]);
-    expect(
-      helper.computeViewableItems(data.length, 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(data.length, 0, 50, getFrameMetrics),
-    ).toEqual([0]);
-    expect(
-      helper.computeViewableItems(data.length, 1, 50, getFrameMetrics),
-    ).toEqual([0, 1]);
-
-    helper = new ViewabilityHelper({itemVisiblePercentThreshold: 100});
-    expect(
-      helper.computeViewableItems(data.length, 0, 250, getFrameMetrics),
-    ).toEqual([0, 1, 2]);
-    expect(
-      helper.computeViewableItems(data.length, 1, 250, getFrameMetrics),
-    ).toEqual([1, 2]);
-
-    helper = new ViewabilityHelper({itemVisiblePercentThreshold: 10});
-    expect(
-      helper.computeViewableItems(data.length, 184, 20, getFrameMetrics),
-    ).toEqual([1]);
-    expect(
-      helper.computeViewableItems(data.length, 185, 20, getFrameMetrics),
-    ).toEqual([1, 2]);
-    expect(
-      helper.computeViewableItems(data.length, 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(
-      data.length,
-      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(
-      data.length,
-      0,
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    expect(onViewableItemsChanged.mock.calls.length).toBe(1); // nothing changed!
-    helper.onUpdate(
-      data.length,
-      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(
-      data.length,
-      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(
-      data.length,
-      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(
-      data.length,
-      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(
-      data.length,
-      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(
-      data.length,
-      0,
-      200,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    helper.onUpdate(
-      data.length,
-      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(
-      data.length,
-      0,
-      100,
-      getFrameMetrics,
-      createViewToken,
-      onViewableItemsChanged,
-    );
-    expect(onViewableItemsChanged).not.toBeCalled();
-
-    helper.recordInteraction();
-
-    helper.onUpdate(
-      data.length,
-      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(
-      data.length,
-      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(
-      data.length,
-      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/Libraries/Lists/__tests__/VirtualizeUtils-test.js

@@ -1,91 +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
- * @emails 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, 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, 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, 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, frames.length, ii => frames[ii], 1),
-    ).toEqual([undefined, 1]);
-  });
-});