@hps1978/react-native-web-tv 0.21.2-tv.0

package/dist/vendor/react-native/FlatList/index.js.flow

@@ -0,0 +1,345 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ */
+
+import View, { type ViewProps } from '../../../exports/View';
+import StyleSheet from '../../../exports/StyleSheet';
+import deepDiffer from '../deepDiffer';
+import Platform from '../../../exports/Platform';
+import invariant from 'fbjs/lib/invariant';
+import * as React from 'react';
+type ScrollViewNativeComponent = any;
+type ViewStyleProp = $PropertyType<ViewProps, 'style'>;
+import type { ViewToken, ViewabilityConfigCallbackPair } from '../ViewabilityHelper';
+import type { RenderItemType, RenderItemProps } from '../VirtualizedList';
+type ScrollResponderType = any;
+import VirtualizedList from '../VirtualizedList';
+import { keyExtractor as defaultKeyExtractor } from '../VirtualizeUtils';
+import memoizeOne from 'memoize-one';
+type $FlowFixMe = any;
+type RequiredProps<ItemT> = {|
+  /**
+   * An array (or array-like list) of items to render. Other data types can be
+   * used by targetting VirtualizedList directly.
+   */
+  data: ?$ArrayLike<ItemT>
+|};
+type OptionalProps<ItemT> = {|
+  /**
+   * Takes an item from `data` and renders it into the list. Example usage:
+   *
+   *     <FlatList
+   *       ItemSeparatorComponent={Platform.OS !== 'android' && ({highlighted}) => (
+   *         <View style={[style.separator, highlighted && {marginLeft: 0}]} />
+   *       )}
+   *       data={[{title: 'Title Text', key: 'item1'}]}
+   *       renderItem={({item, separators}) => (
+   *         <TouchableHighlight
+   *           onPress={() => this._onPress(item)}
+   *           onShowUnderlay={separators.highlight}
+   *           onHideUnderlay={separators.unhighlight}>
+   *           <View style={{backgroundColor: 'white'}}>
+   *             <Text>{item.title}</Text>
+   *           </View>
+   *         </TouchableHighlight>
+   *       )}
+   *     />
+   *
+   * Provides additional metadata like `index` if you need it, as well as a more generic
+   * `separators.updateProps` function which let's you set whatever props you want to change the
+   * rendering of either the leading separator or trailing separator in case the more common
+   * `highlight` and `unhighlight` (which set the `highlighted: boolean` prop) are insufficient for
+   * your use-case.
+   */
+  renderItem?: ?RenderItemType<ItemT>,
+  /**
+   * Optional custom style for multi-item rows generated when numColumns > 1.
+   */
+  columnWrapperStyle?: ViewStyleProp,
+  /**
+   * 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, stick it here and treat it immutably.
+   */
+  extraData?: any,
+  /**
+   * `getItemLayout` is an optional optimizations that let us skip measurement of dynamic content if
+   * you know the height of items a priori. `getItemLayout` is the most efficient, and is easy to
+   * use if you have fixed height items, for example:
+   *
+   *     getItemLayout={(data, index) => (
+   *       {length: ITEM_HEIGHT, offset: ITEM_HEIGHT * index, index}
+   *     )}
+   *
+   * Adding `getItemLayout` can be a great performance boost for lists of several hundred items.
+   * Remember to include separator length (height or width) in your offset calculation if you
+   * specify `ItemSeparatorComponent`.
+   */
+  getItemLayout?: (data: ?$ArrayLike<ItemT>, index: number) => {
+    length: number,
+    offset: number,
+    index: number,
+    ...
+  },
+  /**
+   * If true, renders items next to each other horizontally instead of stacked vertically.
+   */
+  horizontal?: ?boolean,
+  /**
+   * How many items to render in the initial batch. This should be enough to fill the screen but not
+   * much more. Note these items will never be unmounted as part of the windowed rendering in order
+   * to improve perceived performance of scroll-to-top actions.
+   */
+  initialNumToRender?: ?number,
+  /**
+   * Instead of starting at the top with the first item, start at `initialScrollIndex`. This
+   * disables the "scroll to top" optimization that keeps the first `initialNumToRender` items
+   * always rendered and immediately renders the items starting at this initial index. Requires
+   * `getItemLayout` to be implemented.
+   */
+  initialScrollIndex?: ?number,
+  /**
+   * Reverses the direction of scroll. Uses scale transforms of -1.
+   */
+  inverted?: ?boolean,
+  /**
+   * Used to extract a unique key for a given item at the specified index. Key is used for caching
+   * and as the react key to track item re-ordering. The default extractor checks `item.key`, then
+   * falls back to using the index, like React does.
+   */
+  keyExtractor?: ?(item: ItemT, index: number) => string,
+  /**
+   * Multiple columns can only be rendered with `horizontal={false}` and will zig-zag like a
+   * `flexWrap` layout. Items should all be the same height - masonry layouts are not supported.
+   *
+   * The default value is 1.
+   */
+  numColumns?: number,
+  /**
+   * Note: may have bugs (missing content) in some circumstances - use at your own risk.
+   *
+   * This may improve scroll performance for large lists.
+   *
+   * The default value is true for Android.
+   */
+  removeClippedSubviews?: boolean,
+  /**
+   * See `ScrollView` for flow type and further documentation.
+   */
+  fadingEdgeLength?: ?number,
+  /**
+   * Enable an optimization to memoize the item renderer to prevent unnecessary rerenders.
+   */
+  strictMode?: boolean,
+  /**
+   * RecyclerListView optimization: Provide explicit layout for items upfront.
+   * Enables RLV adapter for better performance. Format: (index) => {width, height}
+   */
+  layoutProvider?: ?(index: number) => {
+    width: number,
+    height: number,
+  },
+  /**
+   * RecyclerListView optimization: Per-row change detection for better performance.
+   * Replaces reliance on extraData for finer-grained update control.
+   * Format: (prevRow, nextRow) => boolean (return true if rows are different)
+   */
+  rowHasChanged?: ?(prevRow: any, nextRow: any) => boolean,
+|};
+
+/**
+ * Default Props Helper Functions
+ * Use the following helper functions for default values
+ */
+
+// removeClippedSubviewsOrDefault(this.props.removeClippedSubviews)
+declare function removeClippedSubviewsOrDefault(removeClippedSubviews: ?boolean): any; // numColumnsOrDefault(this.props.numColumns)
+declare function numColumnsOrDefault(numColumns: ?number): any;
+declare function isArrayLike(data: mixed): boolean;
+type FlatListProps<ItemT> = {|
+  ...RequiredProps<ItemT>,
+  ...OptionalProps<ItemT>,
+|};
+type VirtualizedListProps = React.ElementConfig<typeof VirtualizedList>;
+export type Props<ItemT> = {
+  ...$Diff<VirtualizedListProps, {
+    getItem: $PropertyType<VirtualizedListProps, 'getItem'>,
+    getItemCount: $PropertyType<VirtualizedListProps, 'getItemCount'>,
+    getItemLayout: $PropertyType<VirtualizedListProps, 'getItemLayout'>,
+    renderItem: $PropertyType<VirtualizedListProps, 'renderItem'>,
+    keyExtractor: $PropertyType<VirtualizedListProps, 'keyExtractor'>,
+    ...
+  }>,
+  ...FlatListProps<ItemT>,
+  ...
+};
+
+/**
+ * A performant interface for rendering simple, flat lists, supporting the most handy features:
+ *
+ *  - Fully cross-platform.
+ *  - Optional horizontal mode.
+ *  - Configurable viewability callbacks.
+ *  - Header support.
+ *  - Footer support.
+ *  - Separator support.
+ *  - Pull to Refresh.
+ *  - Scroll loading.
+ *  - ScrollToIndex support.
+ *
+ * If you need section support, use [`<SectionList>`](docs/sectionlist.html).
+ *
+ * Minimal Example:
+ *
+ *     <FlatList
+ *       data={[{key: 'a'}, {key: 'b'}]}
+ *       renderItem={({item}) => <Text>{item.key}</Text>}
+ *     />
+ *
+ * More complex, multi-select example demonstrating `PureComponent` usage for perf optimization and avoiding bugs.
+ *
+ * - By binding the `onPressItem` handler, the props will remain `===` and `PureComponent` will
+ *   prevent wasteful re-renders unless the actual `id`, `selected`, or `title` props change, even
+ *   if the components rendered in `MyListItem` did not have such optimizations.
+ * - By passing `extraData={this.state}` to `FlatList` we make sure `FlatList` itself will re-render
+ *   when the `state.selected` changes. Without setting this prop, `FlatList` would not know it
+ *   needs to re-render any items because it is also a `PureComponent` and the prop comparison will
+ *   not show any changes.
+ * - `keyExtractor` tells the list to use the `id`s for the react keys instead of the default `key` property.
+ *
+ *
+ *     class MyListItem extends React.PureComponent {
+ *       _onPress = () => {
+ *         this.props.onPressItem(this.props.id);
+ *       };
+ *
+ *       render() {
+ *         const textColor = this.props.selected ? "red" : "black";
+ *         return (
+ *           <TouchableOpacity onPress={this._onPress}>
+ *             <View>
+ *               <Text style={{ color: textColor }}>
+ *                 {this.props.title}
+ *               </Text>
+ *             </View>
+ *           </TouchableOpacity>
+ *         );
+ *       }
+ *     }
+ *
+ *     class MultiSelectList extends React.PureComponent {
+ *       state = {selected: (new Map(): Map<string, boolean>)};
+ *
+ *       _keyExtractor = (item, index) => item.id;
+ *
+ *       _onPressItem = (id: string) => {
+ *         // updater functions are preferred for transactional updates
+ *         this.setState((state) => {
+ *           // copy the map rather than modifying state.
+ *           const selected = new Map(state.selected);
+ *           selected.set(id, !selected.get(id)); // toggle
+ *           return {selected};
+ *         });
+ *       };
+ *
+ *       _renderItem = ({item}) => (
+ *         <MyListItem
+ *           id={item.id}
+ *           onPressItem={this._onPressItem}
+ *           selected={!!this.state.selected.get(item.id)}
+ *           title={item.title}
+ *         />
+ *       );
+ *
+ *       render() {
+ *         return (
+ *           <FlatList
+ *             data={this.props.data}
+ *             extraData={this.state}
+ *             keyExtractor={this._keyExtractor}
+ *             renderItem={this._renderItem}
+ *           />
+ *         );
+ *       }
+ *     }
+ *
+ * This is a convenience wrapper around [`<VirtualizedList>`](docs/virtualizedlist.html),
+ * and thus inherits its props (as well as those of `ScrollView`) that aren't explicitly listed
+ * here, along with the following caveats:
+ *
+ * - Internal state is not preserved when content scrolls out of the render window. Make sure all
+ *   your data is captured in the item data or external stores like Flux, Redux, or Relay.
+ * - This is a `PureComponent` which means that it will not re-render if `props` remain shallow-
+ *   equal. Make sure that everything your `renderItem` function depends on is passed as a prop
+ *   (e.g. `extraData`) that is not `===` after updates, otherwise your UI may not update on
+ *   changes. This includes the `data` prop and parent component state.
+ * - In order to constrain memory and enable smooth scrolling, content is rendered asynchronously
+ *   offscreen. This means it's possible to scroll faster than the fill rate ands momentarily see
+ *   blank content. This is a tradeoff that can be adjusted to suit the needs of each application,
+ *   and we are working on improving it behind the scenes.
+ * - By default, the list looks for a `key` prop on each item and uses that for the React key.
+ *   Alternatively, you can provide a custom `keyExtractor` prop.
+ *
+ * Also inherits [ScrollView Props](docs/scrollview.html#props), unless it is nested in another FlatList of same orientation.
+ */
+declare class FlatList<ItemT> extends React.PureComponent<Props<ItemT>, void> {
+  props: Props<ItemT>,
+  scrollToEnd(params?: ?{
+    animated?: ?boolean,
+    ...
+  }): any,
+  scrollToIndex(params: {
+    animated?: ?boolean,
+    index: number,
+    viewOffset?: number,
+    viewPosition?: number,
+    ...
+  }): any,
+  scrollToItem(params: {
+    animated?: ?boolean,
+    item: ItemT,
+    viewOffset?: number,
+    viewPosition?: number,
+    ...
+  }): any,
+  scrollToOffset(params: {
+    animated?: ?boolean,
+    offset: number,
+    ...
+  }): any,
+  recordInteraction(): any,
+  flashScrollIndicators(): any,
+  getScrollResponder(): ?ScrollResponderType,
+  getNativeScrollRef(): ?React.ElementRef<typeof View> | ?React.ElementRef<ScrollViewNativeComponent>,
+  getScrollableNode(): any,
+  constructor(props: Props<ItemT>): any,
+  componentDidUpdate(prevProps: Props<ItemT>): any,
+  _listRef: ?React.ElementRef<typeof VirtualizedList>,
+  _virtualizedListPairs: Array<ViewabilityConfigCallbackPair>,
+  _captureRef: any,
+  _checkProps(props: Props<ItemT>): any,
+  _getItem: any,
+  _getItemCount: any,
+  _keyExtractor: any,
+  _pushMultiColumnViewable(arr: Array<ViewToken>, v: ViewToken): void,
+  _createOnViewableItemsChanged(onViewableItemsChanged: ?(info: {
+    viewableItems: Array<ViewToken>,
+    changed: Array<ViewToken>,
+    ...
+  }) => void): any,
+  _renderer: any,
+  _memoizedRenderer: any,
+  render(): React.Node,
+}
+const styles = StyleSheet.create({
+  row: {
+    flexDirection: 'row'
+  }
+});
+export default FlatList;

package/dist/vendor/react-native/JSEventLoopWatchdog/index.js

@@ -0,0 +1,86 @@
+/**
+ * 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
+ * 
+ */
+
+'use strict';
+
+import infoLog from '../infoLog';
+/**
+ * A utility for tracking stalls in the JS event loop that prevent timers and
+ * other events from being processed in a timely manner.
+ *
+ * The "stall" time is defined as the amount of time in access of the acceptable
+ * threshold, which is typically around 100-200ms. So if the treshold is set to
+ * 100 and a timer fires 150 ms later than it was scheduled because the event
+ * loop was tied up, that would be considered a 50ms stall.
+ *
+ * By default, logs stall events to the console when installed. Can also be
+ * queried with `getStats`.
+ */
+var JSEventLoopWatchdog = {
+  getStats: function getStats() {
+    return {
+      stallCount,
+      totalStallTime,
+      longestStall,
+      acceptableBusyTime
+    };
+  },
+  reset: function reset() {
+    infoLog('JSEventLoopWatchdog: reset');
+    totalStallTime = 0;
+    stallCount = 0;
+    longestStall = 0;
+    lastInterval = window.performance.now();
+  },
+  addHandler: function addHandler(handler) {
+    handlers.push(handler);
+  },
+  install: function install(_ref) {
+    var thresholdMS = _ref.thresholdMS;
+    acceptableBusyTime = thresholdMS;
+    if (installed) {
+      return;
+    }
+    installed = true;
+    lastInterval = window.performance.now();
+    function iteration() {
+      var now = window.performance.now();
+      var busyTime = now - lastInterval;
+      if (busyTime >= thresholdMS) {
+        var stallTime = busyTime - thresholdMS;
+        stallCount++;
+        totalStallTime += stallTime;
+        longestStall = Math.max(longestStall, stallTime);
+        var msg = "JSEventLoopWatchdog: JS thread busy for " + busyTime + "ms. " + (totalStallTime + "ms in " + stallCount + " stalls so far. ");
+        handlers.forEach(handler => {
+          msg += handler.onStall({
+            lastInterval,
+            busyTime
+          }) || '';
+        });
+        infoLog(msg);
+      }
+      handlers.forEach(handler => {
+        handler.onIterate && handler.onIterate();
+      });
+      lastInterval = now;
+      setTimeout(iteration, thresholdMS / 5);
+    }
+    iteration();
+  }
+};
+var acceptableBusyTime = 0;
+var installed = false;
+var totalStallTime = 0;
+var stallCount = 0;
+var longestStall = 0;
+var lastInterval = 0;
+var handlers = [];
+export default JSEventLoopWatchdog;

package/dist/vendor/react-native/JSEventLoopWatchdog/index.js.flow

@@ -0,0 +1,75 @@
+/**
+ * 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
+ * @flow
+ */
+
+'use strict';
+
+import infoLog from '../infoLog';
+type Handler = {
+  onIterate?: () => void,
+  onStall: (params: {
+    lastInterval: number,
+    busyTime: number,
+  }) => ?string,
+};
+
+/**
+ * A utility for tracking stalls in the JS event loop that prevent timers and
+ * other events from being processed in a timely manner.
+ *
+ * The "stall" time is defined as the amount of time in access of the acceptable
+ * threshold, which is typically around 100-200ms. So if the treshold is set to
+ * 100 and a timer fires 150 ms later than it was scheduled because the event
+ * loop was tied up, that would be considered a 50ms stall.
+ *
+ * By default, logs stall events to the console when installed. Can also be
+ * queried with `getStats`.
+ */
+const JSEventLoopWatchdog = {
+  getStats: function (): Object {
+    return {
+      stallCount,
+      totalStallTime,
+      longestStall,
+      acceptableBusyTime
+    };
+  },
+  reset: function () {
+    infoLog('JSEventLoopWatchdog: reset');
+    totalStallTime = 0;
+    stallCount = 0;
+    longestStall = 0;
+    lastInterval = window.performance.now();
+  },
+  addHandler: function (handler: Handler) {
+    handlers.push(handler);
+  },
+  install: function ({
+    thresholdMS
+  }: {
+    thresholdMS: number
+  }) {
+    acceptableBusyTime = thresholdMS;
+    if (installed) {
+      return;
+    }
+    installed = true;
+    lastInterval = window.performance.now();
+    declare function iteration(): any;
+    iteration();
+  }
+};
+let acceptableBusyTime = 0;
+let installed = false;
+let totalStallTime = 0;
+let stallCount = 0;
+let longestStall = 0;
+let lastInterval = 0;
+const handlers: Array<Handler> = [];
+export default JSEventLoopWatchdog;

package/dist/vendor/react-native/LayoutAnimation/index.js

@@ -0,0 +1,108 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+import Platform from '../../../exports/Platform';
+import UIManager from '../../../exports/UIManager';
+var __DEV__ = process.env.NODE_ENV !== 'production';
+function configureNext(config, onAnimationDidEnd) {
+  if (!Platform.isTesting) {
+    UIManager.configureNextLayoutAnimation(config, onAnimationDidEnd !== null && onAnimationDidEnd !== void 0 ? onAnimationDidEnd : function () {}, function () {} /* unused onError */);
+  }
+}
+function create(duration, type, property) {
+  return {
+    duration,
+    create: {
+      type,
+      property
+    },
+    update: {
+      type
+    },
+    delete: {
+      type,
+      property
+    }
+  };
+}
+var Presets = {
+  easeInEaseOut: create(300, 'easeInEaseOut', 'opacity'),
+  linear: create(500, 'linear', 'opacity'),
+  spring: {
+    duration: 700,
+    create: {
+      type: 'linear',
+      property: 'opacity'
+    },
+    update: {
+      type: 'spring',
+      springDamping: 0.4
+    },
+    delete: {
+      type: 'linear',
+      property: 'opacity'
+    }
+  }
+};
+
+/**
+ * Automatically animates views to their new positions when the
+ * next layout happens.
+ *
+ * A common way to use this API is to call it before calling `setState`.
+ *
+ * Note that in order to get this to work on **Android** you need to set the following flags via `UIManager`:
+ *
+ *     UIManager.setLayoutAnimationEnabledExperimental && UIManager.setLayoutAnimationEnabledExperimental(true);
+ */
+var LayoutAnimation = {
+  /**
+   * Schedules an animation to happen on the next layout.
+   *
+   * @param config Specifies animation properties:
+   *
+   *   - `duration` in milliseconds
+   *   - `create`, `AnimationConfig` for animating in new views
+   *   - `update`, `AnimationConfig` for animating views that have been updated
+   *
+   * @param onAnimationDidEnd Called when the animation finished.
+   * Only supported on iOS.
+   * @param onError Called on error. Only supported on iOS.
+   */
+  configureNext,
+  /**
+   * Helper for creating a config for `configureNext`.
+   */
+  create,
+  Types: Object.freeze({
+    spring: 'spring',
+    linear: 'linear',
+    easeInEaseOut: 'easeInEaseOut',
+    easeIn: 'easeIn',
+    easeOut: 'easeOut',
+    keyboard: 'keyboard'
+  }),
+  Properties: Object.freeze({
+    opacity: 'opacity',
+    scaleX: 'scaleX',
+    scaleY: 'scaleY',
+    scaleXY: 'scaleXY'
+  }),
+  checkConfig() {
+    console.error('LayoutAnimation.checkConfig(...) has been disabled.');
+  },
+  Presets,
+  easeInEaseOut: configureNext.bind(null, Presets.easeInEaseOut),
+  linear: configureNext.bind(null, Presets.linear),
+  spring: configureNext.bind(null, Presets.spring)
+};
+export default LayoutAnimation;