@depup/react-native-web 0.21.2-depup.0

package/dist/vendor/react-native/VirtualizedList/ChildListCollection.js

@@ -0,0 +1,68 @@
+import _createForOfIteratorHelperLoose from "@babel/runtime/helpers/createForOfIteratorHelperLoose";
+/**
+ * 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
+ */
+
+import invariant from 'fbjs/lib/invariant';
+export default class ChildListCollection {
+  constructor() {
+    this._cellKeyToChildren = new Map();
+    this._childrenToCellKey = new Map();
+  }
+  add(list, cellKey) {
+    var _this$_cellKeyToChild;
+    invariant(!this._childrenToCellKey.has(list), 'Trying to add already present child list');
+    var cellLists = (_this$_cellKeyToChild = this._cellKeyToChildren.get(cellKey)) !== null && _this$_cellKeyToChild !== void 0 ? _this$_cellKeyToChild : new Set();
+    cellLists.add(list);
+    this._cellKeyToChildren.set(cellKey, cellLists);
+    this._childrenToCellKey.set(list, cellKey);
+  }
+  remove(list) {
+    var cellKey = this._childrenToCellKey.get(list);
+    invariant(cellKey != null, 'Trying to remove non-present child list');
+    this._childrenToCellKey.delete(list);
+    var cellLists = this._cellKeyToChildren.get(cellKey);
+    invariant(cellLists, '_cellKeyToChildren should contain cellKey');
+    cellLists.delete(list);
+    if (cellLists.size === 0) {
+      this._cellKeyToChildren.delete(cellKey);
+    }
+  }
+  forEach(fn) {
+    for (var _iterator = _createForOfIteratorHelperLoose(this._cellKeyToChildren.values()), _step; !(_step = _iterator()).done;) {
+      var listSet = _step.value;
+      for (var _iterator2 = _createForOfIteratorHelperLoose(listSet), _step2; !(_step2 = _iterator2()).done;) {
+        var list = _step2.value;
+        fn(list);
+      }
+    }
+  }
+  forEachInCell(cellKey, fn) {
+    var _this$_cellKeyToChild2;
+    var listSet = (_this$_cellKeyToChild2 = this._cellKeyToChildren.get(cellKey)) !== null && _this$_cellKeyToChild2 !== void 0 ? _this$_cellKeyToChild2 : [];
+    for (var _iterator3 = _createForOfIteratorHelperLoose(listSet), _step3; !(_step3 = _iterator3()).done;) {
+      var list = _step3.value;
+      fn(list);
+    }
+  }
+  anyInCell(cellKey, fn) {
+    var _this$_cellKeyToChild3;
+    var listSet = (_this$_cellKeyToChild3 = this._cellKeyToChildren.get(cellKey)) !== null && _this$_cellKeyToChild3 !== void 0 ? _this$_cellKeyToChild3 : [];
+    for (var _iterator4 = _createForOfIteratorHelperLoose(listSet), _step4; !(_step4 = _iterator4()).done;) {
+      var list = _step4.value;
+      if (fn(list)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  size() {
+    return this._childrenToCellKey.size;
+  }
+}

package/dist/vendor/react-native/VirtualizedList/ChildListCollection.js.flow

@@ -0,0 +1,21 @@
+/**
+ * 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 strict
+ * @format
+ */
+
+import invariant from 'fbjs/lib/invariant';
+declare export default class ChildListCollection<TList> {
+  _cellKeyToChildren: Map<string, Set<TList>>,
+  _childrenToCellKey: Map<TList, string>,
+  add(list: TList, cellKey: string): void,
+  remove(list: TList): void,
+  forEach(fn: (TList) => void): void,
+  forEachInCell(cellKey: string, fn: (TList) => void): void,
+  anyInCell(cellKey: string, fn: (TList) => boolean): boolean,
+  size(): number,
+}

package/dist/vendor/react-native/VirtualizedList/StateSafePureComponent.js

@@ -0,0 +1,70 @@
+/**
+ * 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
+ */
+
+import invariant from 'fbjs/lib/invariant';
+import * as React from 'react';
+
+/**
+ * `setState` is called asynchronously, and should not rely on the value of
+ * `this.props` or `this.state`:
+ * https://reactjs.org/docs/state-and-lifecycle.html#state-updates-may-be-asynchronous
+ *
+ * SafePureComponent adds runtime enforcement, to catch cases where these
+ * variables are read in a state updater function, instead of the ones passed
+ * in.
+ */
+export default class StateSafePureComponent extends React.PureComponent {
+  constructor(props) {
+    super(props);
+    this._inAsyncStateUpdate = false;
+    this._installSetStateHooks();
+  }
+  setState(partialState, callback) {
+    if (typeof partialState === 'function') {
+      super.setState((state, props) => {
+        this._inAsyncStateUpdate = true;
+        var ret;
+        try {
+          ret = partialState(state, props);
+        } catch (err) {
+          throw err;
+        } finally {
+          this._inAsyncStateUpdate = false;
+        }
+        return ret;
+      }, callback);
+    } else {
+      super.setState(partialState, callback);
+    }
+  }
+  _installSetStateHooks() {
+    var that = this;
+    var props = this.props,
+      state = this.state;
+    Object.defineProperty(this, 'props', {
+      get() {
+        invariant(!that._inAsyncStateUpdate, '"this.props" should not be accessed during state updates');
+        return props;
+      },
+      set(newProps) {
+        props = newProps;
+      }
+    });
+    Object.defineProperty(this, 'state', {
+      get() {
+        invariant(!that._inAsyncStateUpdate, '"this.state" should not be acceessed during state updates');
+        return state;
+      },
+      set(newState) {
+        state = newState;
+      }
+    });
+  }
+}

package/dist/vendor/react-native/VirtualizedList/StateSafePureComponent.js.flow

@@ -0,0 +1,28 @@
+/**
+ * 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 strict
+ * @format
+ */
+
+import invariant from 'fbjs/lib/invariant';
+import * as React from 'react';
+
+/**
+ * `setState` is called asynchronously, and should not rely on the value of
+ * `this.props` or `this.state`:
+ * https://reactjs.org/docs/state-and-lifecycle.html#state-updates-may-be-asynchronous
+ *
+ * SafePureComponent adds runtime enforcement, to catch cases where these
+ * variables are read in a state updater function, instead of the ones passed
+ * in.
+ */
+declare export default class StateSafePureComponent<Props, State: interface {}> extends React.PureComponent<Props, State> {
+  _inAsyncStateUpdate: any,
+  constructor(props: Props): any,
+  setState(partialState: ?($Shape<State> | ((State, Props) => ?$Shape<State>)), callback?: () => mixed): void,
+  _installSetStateHooks(): any,
+}

package/dist/vendor/react-native/VirtualizedList/VirtualizedListCellRenderer.js

@@ -0,0 +1,153 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+/**
+ * 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
+ */
+
+import View from '../../../exports/View';
+import StyleSheet from '../../../exports/StyleSheet';
+import { VirtualizedListCellContextProvider } from './VirtualizedListContext.js';
+import invariant from 'fbjs/lib/invariant';
+import * as React from 'react';
+export default class CellRenderer extends React.Component {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      separatorProps: {
+        highlighted: false,
+        leadingItem: this.props.item
+      }
+    };
+    this._separators = {
+      highlight: () => {
+        var _this$props = this.props,
+          cellKey = _this$props.cellKey,
+          prevCellKey = _this$props.prevCellKey;
+        this.props.onUpdateSeparators([cellKey, prevCellKey], {
+          highlighted: true
+        });
+      },
+      unhighlight: () => {
+        var _this$props2 = this.props,
+          cellKey = _this$props2.cellKey,
+          prevCellKey = _this$props2.prevCellKey;
+        this.props.onUpdateSeparators([cellKey, prevCellKey], {
+          highlighted: false
+        });
+      },
+      updateProps: (select, newProps) => {
+        var _this$props3 = this.props,
+          cellKey = _this$props3.cellKey,
+          prevCellKey = _this$props3.prevCellKey;
+        this.props.onUpdateSeparators([select === 'leading' ? prevCellKey : cellKey], newProps);
+      }
+    };
+    this._onLayout = nativeEvent => {
+      this.props.onCellLayout && this.props.onCellLayout(nativeEvent, this.props.cellKey, this.props.index);
+    };
+  }
+  static getDerivedStateFromProps(props, prevState) {
+    return {
+      separatorProps: _objectSpread(_objectSpread({}, prevState.separatorProps), {}, {
+        leadingItem: props.item
+      })
+    };
+  }
+
+  // TODO: consider factoring separator stuff out of VirtualizedList into FlatList since it's not
+  // reused by SectionList and we can keep VirtualizedList simpler.
+  // $FlowFixMe[missing-local-annot]
+
+  updateSeparatorProps(newProps) {
+    this.setState(state => ({
+      separatorProps: _objectSpread(_objectSpread({}, state.separatorProps), newProps)
+    }));
+  }
+  componentWillUnmount() {
+    this.props.onUnmount(this.props.cellKey);
+  }
+  _renderElement(renderItem, ListItemComponent, item, index) {
+    if (renderItem && ListItemComponent) {
+      console.warn('VirtualizedList: Both ListItemComponent and renderItem props are present. ListItemComponent will take' + ' precedence over renderItem.');
+    }
+    if (ListItemComponent) {
+      /* $FlowFixMe[not-a-component] (>=0.108.0 site=react_native_fb) This
+       * comment suppresses an error found when Flow v0.108 was deployed. To
+       * see the error, delete this comment and run Flow. */
+      /* $FlowFixMe[incompatible-type-arg] (>=0.108.0 site=react_native_fb)
+       * This comment suppresses an error found when Flow v0.108 was deployed.
+       * To see the error, delete this comment and run Flow. */
+      return /*#__PURE__*/React.createElement(ListItemComponent, {
+        item,
+        index,
+        separators: this._separators
+      });
+    }
+    if (renderItem) {
+      return renderItem({
+        item,
+        index,
+        separators: this._separators
+      });
+    }
+    invariant(false, 'VirtualizedList: Either ListItemComponent or renderItem props are required but none were found.');
+  }
+  render() {
+    var _this$props4 = this.props,
+      CellRendererComponent = _this$props4.CellRendererComponent,
+      ItemSeparatorComponent = _this$props4.ItemSeparatorComponent,
+      ListItemComponent = _this$props4.ListItemComponent,
+      cellKey = _this$props4.cellKey,
+      horizontal = _this$props4.horizontal,
+      item = _this$props4.item,
+      index = _this$props4.index,
+      inversionStyle = _this$props4.inversionStyle,
+      onCellFocusCapture = _this$props4.onCellFocusCapture,
+      onCellLayout = _this$props4.onCellLayout,
+      renderItem = _this$props4.renderItem;
+    var element = this._renderElement(renderItem, ListItemComponent, item, index);
+
+    // NOTE: that when this is a sticky header, `onLayout` will get automatically extracted and
+    // called explicitly by `ScrollViewStickyHeader`.
+    var itemSeparator = /*#__PURE__*/React.isValidElement(ItemSeparatorComponent) ?
+    // $FlowFixMe[incompatible-type]
+    ItemSeparatorComponent :
+    // $FlowFixMe[incompatible-type]
+    ItemSeparatorComponent && /*#__PURE__*/React.createElement(ItemSeparatorComponent, this.state.separatorProps);
+    var cellStyle = inversionStyle ? horizontal ? [styles.rowReverse, inversionStyle] : [styles.columnReverse, inversionStyle] : horizontal ? [styles.row, inversionStyle] : inversionStyle;
+    var result = !CellRendererComponent ? /*#__PURE__*/React.createElement(View, _extends({
+      style: cellStyle,
+      onFocusCapture: onCellFocusCapture
+    }, onCellLayout && {
+      onLayout: this._onLayout
+    }), element, itemSeparator) : /*#__PURE__*/React.createElement(CellRendererComponent, _extends({
+      cellKey: cellKey,
+      index: index,
+      item: item,
+      style: cellStyle,
+      onFocusCapture: onCellFocusCapture
+    }, onCellLayout && {
+      onLayout: this._onLayout
+    }), element, itemSeparator);
+    return /*#__PURE__*/React.createElement(VirtualizedListCellContextProvider, {
+      cellKey: this.props.cellKey
+    }, result);
+  }
+}
+var styles = StyleSheet.create({
+  row: {
+    flexDirection: 'row'
+  },
+  rowReverse: {
+    flexDirection: 'row-reverse'
+  },
+  columnReverse: {
+    flexDirection: 'column-reverse'
+  }
+});

package/dist/vendor/react-native/VirtualizedList/VirtualizedListCellRenderer.js.flow

@@ -0,0 +1,68 @@
+/**
+ * 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 type { LayoutEvent } from '../../../types';
+import type { FocusEvent } from '../Types/CoreEventTypes';
+import type { CellRendererProps, RenderItemType } from './VirtualizedListProps';
+import View, { type ViewProps } from '../../../exports/View';
+import StyleSheet from '../../../exports/StyleSheet';
+import { VirtualizedListCellContextProvider } from './VirtualizedListContext.js';
+import invariant from 'fbjs/lib/invariant';
+import * as React from 'react';
+type ViewStyleProp = $PropertyType<ViewProps, 'style'>;
+export type Props<ItemT> = {
+  CellRendererComponent?: ?React.ComponentType<CellRendererProps<ItemT>>,
+  ItemSeparatorComponent: ?React.ComponentType<any | {
+    highlighted: boolean,
+    leadingItem: ?ItemT,
+  }>,
+  ListItemComponent?: ?(React.ComponentType<any> | React.Element<any>),
+  cellKey: string,
+  horizontal: ?boolean,
+  index: number,
+  inversionStyle: ViewStyleProp,
+  item: ItemT,
+  onCellLayout?: (event: LayoutEvent, cellKey: string, index: number) => void,
+  onCellFocusCapture?: (event: FocusEvent) => void,
+  onUnmount: (cellKey: string) => void,
+  onUpdateSeparators: (cellKeys: Array<?string>, props: $Shape<SeparatorProps<ItemT>>) => void,
+  prevCellKey: ?string,
+  renderItem?: ?RenderItemType<ItemT>,
+  ...
+};
+type SeparatorProps<ItemT> = $ReadOnly<{|
+  highlighted: boolean,
+  leadingItem: ?ItemT,
+|}>;
+type State<ItemT> = {
+  separatorProps: SeparatorProps<ItemT>,
+  ...
+};
+declare export default class CellRenderer<ItemT> extends React.Component<Props<ItemT>, State<ItemT>> {
+  state: State<ItemT>,
+  static getDerivedStateFromProps(props: Props<ItemT>, prevState: State<ItemT>): ?State<ItemT>,
+  _separators: any,
+  updateSeparatorProps(newProps: SeparatorProps<ItemT>): any,
+  componentWillUnmount(): any,
+  _onLayout: any,
+  _renderElement(renderItem: ?RenderItemType<ItemT>, ListItemComponent: any, item: ItemT, index: number): React.Node,
+  render(): React.Node,
+}
+const styles = StyleSheet.create({
+  row: {
+    flexDirection: 'row'
+  },
+  rowReverse: {
+    flexDirection: 'row-reverse'
+  },
+  columnReverse: {
+    flexDirection: 'column-reverse'
+  }
+});

package/dist/vendor/react-native/VirtualizedList/VirtualizedListContext.js

@@ -0,0 +1,64 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+/**
+ * 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
+ */
+
+import * as React from 'react';
+import { useContext, useMemo } from 'react';
+var __DEV__ = process.env.NODE_ENV !== 'production';
+export var VirtualizedListContext = /*#__PURE__*/React.createContext(null);
+if (__DEV__) {
+  VirtualizedListContext.displayName = 'VirtualizedListContext';
+}
+
+/**
+ * Resets the context. Intended for use by portal-like components (e.g. Modal).
+ */
+export function VirtualizedListContextResetter(_ref) {
+  var children = _ref.children;
+  return /*#__PURE__*/React.createElement(VirtualizedListContext.Provider, {
+    value: null
+  }, children);
+}
+
+/**
+ * Sets the context with memoization. Intended to be used by `VirtualizedList`.
+ */
+export function VirtualizedListContextProvider(_ref2) {
+  var children = _ref2.children,
+    value = _ref2.value;
+  // Avoid setting a newly created context object if the values are identical.
+  var context = useMemo(() => ({
+    cellKey: null,
+    getScrollMetrics: value.getScrollMetrics,
+    horizontal: value.horizontal,
+    getOutermostParentListRef: value.getOutermostParentListRef,
+    registerAsNestedChild: value.registerAsNestedChild,
+    unregisterAsNestedChild: value.unregisterAsNestedChild
+  }), [value.getScrollMetrics, value.horizontal, value.getOutermostParentListRef, value.registerAsNestedChild, value.unregisterAsNestedChild]);
+  return /*#__PURE__*/React.createElement(VirtualizedListContext.Provider, {
+    value: context
+  }, children);
+}
+
+/**
+ * Sets the `cellKey`. Intended to be used by `VirtualizedList` for each cell.
+ */
+export function VirtualizedListCellContextProvider(_ref3) {
+  var cellKey = _ref3.cellKey,
+    children = _ref3.children;
+  // Avoid setting a newly created context object if the values are identical.
+  var currContext = useContext(VirtualizedListContext);
+  var context = useMemo(() => currContext == null ? null : _objectSpread(_objectSpread({}, currContext), {}, {
+    cellKey
+  }), [currContext, cellKey]);
+  return /*#__PURE__*/React.createElement(VirtualizedListContext.Provider, {
+    value: context
+  }, children);
+}

package/dist/vendor/react-native/VirtualizedList/VirtualizedListContext.js.flow

@@ -0,0 +1,61 @@
+/**
+ * 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 strict-local
+ * @format
+ */
+
+import typeof VirtualizedList from '../VirtualizedList';
+import * as React from 'react';
+import { useContext, useMemo } from 'react';
+const __DEV__ = process.env.NODE_ENV !== 'production';
+type Context = $ReadOnly<{
+  cellKey: ?string,
+  getScrollMetrics: () => {
+    contentLength: number,
+    dOffset: number,
+    dt: number,
+    offset: number,
+    timestamp: number,
+    velocity: number,
+    visibleLength: number,
+    zoomScale: number,
+  },
+  horizontal: ?boolean,
+  getOutermostParentListRef: () => React.ElementRef<VirtualizedList>,
+  registerAsNestedChild: ({
+    cellKey: string,
+    ref: React.ElementRef<VirtualizedList>,
+  }) => void,
+  unregisterAsNestedChild: ({
+    ref: React.ElementRef<VirtualizedList>
+  }) => void,
+}>;
+export const VirtualizedListContext: React.Context<?Context> = React.createContext(null);
+if (__DEV__) {
+  VirtualizedListContext.displayName = 'VirtualizedListContext';
+}
+
+/**
+ * Resets the context. Intended for use by portal-like components (e.g. Modal).
+ */
+declare export function VirtualizedListContextResetter(arg0: {
+  children: React.Node
+}): React.Node;
+/**
+ * Sets the context with memoization. Intended to be used by `VirtualizedList`.
+ */
+declare export function VirtualizedListContextProvider(arg0: {
+  children: React.Node,
+  value: Context,
+}): React.Node;
+/**
+ * Sets the `cellKey`. Intended to be used by `VirtualizedList` for each cell.
+ */
+declare export function VirtualizedListCellContextProvider(arg0: {
+  cellKey: string,
+  children: React.Node,
+}): React.Node;

package/dist/vendor/react-native/VirtualizedList/VirtualizedListProps.js

@@ -0,0 +1,16 @@
+/**
+ * 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
+ */
+
+import ScrollView from '../../../exports/ScrollView';
+import * as React from 'react';
+
+/**
+ * Subset of properties needed to calculate frame metrics
+ */