yeet

node_modules/react-native/Libraries/Components/ScrollView/AndroidHorizontalScrollContentViewNativeComponent.js

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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';
+
+const registerGeneratedViewConfig = require('../../Utilities/registerGeneratedViewConfig');
+const requireNativeComponent = require('../../ReactNative/requireNativeComponent');
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+const AndroidHorizontalScrollContentViewViewConfig = {
+  uiViewClassName: 'AndroidHorizontalScrollContentView',
+  bubblingEventTypes: {},
+  directEventTypes: {},
+  validAttributes: {},
+};
+
+let AndroidHorizontalScrollContentViewNativeComponent;
+if (global.RN$Bridgeless) {
+  registerGeneratedViewConfig(
+    'AndroidHorizontalScrollContentView',
+    AndroidHorizontalScrollContentViewViewConfig,
+  );
+  AndroidHorizontalScrollContentViewNativeComponent =
+    'AndroidHorizontalScrollContentView';
+} else {
+  AndroidHorizontalScrollContentViewNativeComponent = requireNativeComponent<ViewProps>(
+    'AndroidHorizontalScrollContentView',
+  );
+}
+
+export default ((AndroidHorizontalScrollContentViewNativeComponent: any): HostComponent<ViewProps>);

node_modules/react-native/Libraries/Components/ScrollView/AndroidHorizontalScrollViewNativeComponent.js

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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';
+
+const registerGeneratedViewConfig = require('../../Utilities/registerGeneratedViewConfig');
+const requireNativeComponent = require('../../ReactNative/requireNativeComponent');
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ScrollViewNativeProps} from './ScrollViewNativeComponentType';
+
+const AndroidHorizontalScrollViewViewConfig = {
+  uiViewClassName: 'AndroidHorizontalScrollView',
+  bubblingEventTypes: {},
+  directEventTypes: {},
+  validAttributes: {
+    decelerationRate: true,
+    disableIntervalMomentum: true,
+    endFillColor: {process: require('../../StyleSheet/processColor')},
+    fadingEdgeLength: true,
+    nestedScrollEnabled: true,
+    overScrollMode: true,
+    pagingEnabled: true,
+    persistentScrollbar: true,
+    scrollEnabled: true,
+    scrollPerfTag: true,
+    sendMomentumEvents: true,
+    showsHorizontalScrollIndicator: true,
+    snapToEnd: true,
+    snapToInterval: true,
+    snapToStart: true,
+    snapToOffsets: true,
+    contentOffset: true,
+  },
+};
+
+let AndroidHorizontalScrollViewNativeComponent;
+if (global.RN$Bridgeless) {
+  registerGeneratedViewConfig(
+    'AndroidHorizontalScrollView',
+    AndroidHorizontalScrollViewViewConfig,
+  );
+  AndroidHorizontalScrollViewNativeComponent = 'AndroidHorizontalScrollView';
+} else {
+  AndroidHorizontalScrollViewNativeComponent = requireNativeComponent<ScrollViewNativeProps>(
+    'AndroidHorizontalScrollView',
+  );
+}
+
+export default ((AndroidHorizontalScrollViewNativeComponent: any): HostComponent<ScrollViewNativeProps>);

node_modules/react-native/Libraries/Components/ScrollView/ScrollContentViewNativeComponent.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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';
+
+const registerGeneratedViewConfig = require('../../Utilities/registerGeneratedViewConfig');
+const requireNativeComponent = require('../../ReactNative/requireNativeComponent');
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+const ScrollContentViewViewConfig = {
+  uiViewClassName: 'RCTScrollContentView',
+  bubblingEventTypes: {},
+  directEventTypes: {},
+  validAttributes: {},
+};
+
+let ScrollContentViewNativeComponent;
+if (global.RN$Bridgeless) {
+  registerGeneratedViewConfig(
+    'RCTScrollContentView',
+    ScrollContentViewViewConfig,
+  );
+  ScrollContentViewNativeComponent = 'RCTScrollContentView';
+} else {
+  ScrollContentViewNativeComponent = requireNativeComponent<ViewProps>(
+    'RCTScrollContentView',
+  );
+}
+
+export default ((ScrollContentViewNativeComponent: any): HostComponent<ViewProps>);

node_modules/react-native/Libraries/Components/ScrollView/ScrollViewCommands.js

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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 strict-local
+ */
+
+import codegenNativeCommands from '../../Utilities/codegenNativeCommands';
+import * as React from 'react';
+import type {Double} from 'react-native/Libraries/Types/CodegenTypes';
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+
+type ScrollViewNativeComponentType = HostComponent<mixed>;
+interface NativeCommands {
+  +flashScrollIndicators: (
+    viewRef: React.ElementRef<ScrollViewNativeComponentType>,
+  ) => void;
+  +scrollTo: (
+    viewRef: React.ElementRef<ScrollViewNativeComponentType>,
+    x: Double,
+    y: Double,
+    animated: boolean,
+  ) => void;
+  +scrollToEnd: (
+    viewRef: React.ElementRef<ScrollViewNativeComponentType>,
+    animated: boolean,
+  ) => void;
+  +zoomToRect: (
+    viewRef: React.ElementRef<ScrollViewNativeComponentType>,
+    rect: {|
+      x: Double,
+      y: Double,
+      width: Double,
+      height: Double,
+      animated?: boolean,
+    |},
+    animated?: boolean,
+  ) => void;
+}
+
+export default (codegenNativeCommands<NativeCommands>({
+  supportedCommands: [
+    'flashScrollIndicators',
+    'scrollTo',
+    'scrollToEnd',
+    'zoomToRect',
+  ],
+}): NativeCommands);

node_modules/react-native/Libraries/Components/ScrollView/ScrollViewNativeComponent.js

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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';
+
+const registerGeneratedViewConfig = require('../../Utilities/registerGeneratedViewConfig');
+const requireNativeComponent = require('../../ReactNative/requireNativeComponent');
+import ScrollViewViewConfig from './ScrollViewViewConfig';
+
+import type {
+  ScrollViewNativeProps,
+  ScrollViewNativeComponentType,
+} from './ScrollViewNativeComponentType';
+
+let ScrollViewNativeComponent;
+if (global.RN$Bridgeless) {
+  registerGeneratedViewConfig('RCTScrollView', ScrollViewViewConfig);
+  ScrollViewNativeComponent = 'RCTScrollView';
+} else {
+  ScrollViewNativeComponent = requireNativeComponent<ScrollViewNativeProps>(
+    'RCTScrollView',
+  );
+}
+
+export default ((ScrollViewNativeComponent: any): ScrollViewNativeComponentType);

node_modules/react-native/Libraries/Components/ScrollView/ScrollViewNativeComponentType.js

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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 type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+import type {
+  ViewStyleProp,
+  DangerouslyImpreciseStyle,
+} from '../../StyleSheet/StyleSheet';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {EdgeInsetsProp} from '../../StyleSheet/EdgeInsetsPropType';
+import type {ScrollEvent} from '../../Types/CoreEventTypes';
+import type {PointProp} from '../../StyleSheet/PointPropType';
+
+export type ScrollViewNativeProps = $ReadOnly<{
+  ...ViewProps,
+  alwaysBounceHorizontal?: ?boolean,
+  alwaysBounceVertical?: ?boolean,
+  automaticallyAdjustContentInsets?: ?boolean,
+  bounces?: ?boolean,
+  bouncesZoom?: ?boolean,
+  canCancelContentTouches?: ?boolean,
+  centerContent?: ?boolean,
+  contentInset?: ?EdgeInsetsProp,
+  contentInsetAdjustmentBehavior?: ?(
+    | 'automatic'
+    | 'scrollableAxes'
+    | 'never'
+    | 'always'
+  ),
+  contentOffset?: ?PointProp,
+  decelerationRate?: ?('fast' | 'normal' | number),
+  directionalLockEnabled?: ?boolean,
+  disableIntervalMomentum?: ?boolean,
+  endFillColor?: ?ColorValue,
+  fadingEdgeLength?: ?number,
+  indicatorStyle?: ?('default' | 'black' | 'white'),
+  keyboardDismissMode?: ?('none' | 'on-drag' | 'interactive'),
+  maintainVisibleContentPosition?: ?$ReadOnly<{|
+    minIndexForVisible: number,
+    autoscrollToTopThreshold?: ?number,
+  |}>,
+  maximumZoomScale?: ?number,
+  minimumZoomScale?: ?number,
+  nestedScrollEnabled?: ?boolean,
+  onMomentumScrollBegin?: ?(event: ScrollEvent) => void,
+  onMomentumScrollEnd?: ?(event: ScrollEvent) => void,
+  onScroll?: ?(event: ScrollEvent) => void,
+  onScrollBeginDrag?: ?(event: ScrollEvent) => void,
+  onScrollEndDrag?: ?(event: ScrollEvent) => void,
+  onScrollToTop?: (event: ScrollEvent) => void,
+  overScrollMode?: ?('auto' | 'always' | 'never'),
+  pagingEnabled?: ?boolean,
+  persistentScrollbar?: ?boolean,
+  pinchGestureEnabled?: ?boolean,
+  scrollEnabled?: ?boolean,
+  scrollEventThrottle?: ?number,
+  scrollIndicatorInsets?: ?EdgeInsetsProp,
+  scrollPerfTag?: ?string,
+  scrollToOverflowEnabled?: ?boolean,
+  scrollsToTop?: ?boolean,
+  sendMomentumEvents?: ?boolean,
+  showsHorizontalScrollIndicator?: ?boolean,
+  showsVerticalScrollIndicator?: ?boolean,
+  snapToAlignment?: ?('start' | 'center' | 'end'),
+  snapToEnd?: ?boolean,
+  snapToInterval?: ?number,
+  snapToOffsets?: ?$ReadOnlyArray<number>,
+  snapToStart?: ?boolean,
+  zoomScale?: ?number,
+  DEPRECATED_sendUpdatedChildFrames?: ?boolean,
+  // Overrides
+  style?: {...ViewStyleProp, ...} | DangerouslyImpreciseStyle,
+  onResponderGrant?: ?(e: any) => void | boolean,
+  ...
+}>;
+
+export type ScrollViewNativeComponentType = HostComponent<ScrollViewNativeProps>;

node_modules/react-native/Libraries/Components/ScrollView/ScrollViewStickyHeader.js

@@ -0,0 +1,166 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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
+ */
+
+'use strict';
+
+const AnimatedImplementation = require('../../Animated/src/AnimatedImplementation');
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const View = require('../View/View');
+
+import type {LayoutEvent} from '../../Types/CoreEventTypes';
+
+const AnimatedView = AnimatedImplementation.createAnimatedComponent(View);
+
+export type Props = {
+  children?: React.Element<any>,
+  nextHeaderLayoutY: ?number,
+  onLayout: (event: LayoutEvent) => void,
+  scrollAnimatedValue: AnimatedImplementation.Value,
+  // Will cause sticky headers to stick at the bottom of the ScrollView instead
+  // of the top.
+  inverted: ?boolean,
+  // The height of the parent ScrollView. Currently only set when inverted.
+  scrollViewHeight: ?number,
+  ...
+};
+
+type State = {
+  measured: boolean,
+  layoutY: number,
+  layoutHeight: number,
+  nextHeaderLayoutY: ?number,
+  ...
+};
+
+class ScrollViewStickyHeader extends React.Component<Props, State> {
+  state: State = {
+    measured: false,
+    layoutY: 0,
+    layoutHeight: 0,
+    nextHeaderLayoutY: this.props.nextHeaderLayoutY,
+  };
+
+  setNextHeaderY(y: number) {
+    this.setState({nextHeaderLayoutY: y});
+  }
+
+  _onLayout = event => {
+    this.setState({
+      measured: true,
+      layoutY: event.nativeEvent.layout.y,
+      layoutHeight: event.nativeEvent.layout.height,
+    });
+
+    this.props.onLayout(event);
+    const child = React.Children.only(this.props.children);
+    if (child.props.onLayout) {
+      child.props.onLayout(event);
+    }
+  };
+
+  render(): React.Node {
+    const {inverted, scrollViewHeight} = this.props;
+    const {measured, layoutHeight, layoutY, nextHeaderLayoutY} = this.state;
+    const inputRange: Array<number> = [-1, 0];
+    const outputRange: Array<number> = [0, 0];
+
+    if (measured) {
+      if (inverted) {
+        // The interpolation looks like:
+        // - Negative scroll: no translation
+        // - `stickStartPoint` is the point at which the header will start sticking.
+        //   It is calculated using the ScrollView viewport height so it is a the bottom.
+        // - Headers that are in the initial viewport will never stick, `stickStartPoint`
+        //   will be negative.
+        // - From 0 to `stickStartPoint` no translation. This will cause the header
+        //   to scroll normally until it reaches the top of the scroll view.
+        // - From `stickStartPoint` to when the next header y hits the bottom edge of the header: translate
+        //   equally to scroll. This will cause the header to stay at the top of the scroll view.
+        // - Past the collision with the next header y: no more translation. This will cause the
+        //   header to continue scrolling up and make room for the next sticky header.
+        //   In the case that there is no next header just translate equally to
+        //   scroll indefinitely.
+        if (scrollViewHeight != null) {
+          const stickStartPoint = layoutY + layoutHeight - scrollViewHeight;
+          if (stickStartPoint > 0) {
+            inputRange.push(stickStartPoint);
+            outputRange.push(0);
+            inputRange.push(stickStartPoint + 1);
+            outputRange.push(1);
+            // If the next sticky header has not loaded yet (probably windowing) or is the last
+            // we can just keep it sticked forever.
+            const collisionPoint =
+              (nextHeaderLayoutY || 0) - layoutHeight - scrollViewHeight;
+            if (collisionPoint > stickStartPoint) {
+              inputRange.push(collisionPoint, collisionPoint + 1);
+              outputRange.push(
+                collisionPoint - stickStartPoint,
+                collisionPoint - stickStartPoint,
+              );
+            }
+          }
+        }
+      } else {
+        // The interpolation looks like:
+        // - Negative scroll: no translation
+        // - From 0 to the y of the header: no translation. This will cause the header
+        //   to scroll normally until it reaches the top of the scroll view.
+        // - From header y to when the next header y hits the bottom edge of the header: translate
+        //   equally to scroll. This will cause the header to stay at the top of the scroll view.
+        // - Past the collision with the next header y: no more translation. This will cause the
+        //   header to continue scrolling up and make room for the next sticky header.
+        //   In the case that there is no next header just translate equally to
+        //   scroll indefinitely.
+        inputRange.push(layoutY);
+        outputRange.push(0);
+        // If the next sticky header has not loaded yet (probably windowing) or is the last
+        // we can just keep it sticked forever.
+        const collisionPoint = (nextHeaderLayoutY || 0) - layoutHeight;
+        if (collisionPoint >= layoutY) {
+          inputRange.push(collisionPoint, collisionPoint + 1);
+          outputRange.push(collisionPoint - layoutY, collisionPoint - layoutY);
+        } else {
+          inputRange.push(layoutY + 1);
+          outputRange.push(1);
+        }
+      }
+    }
+
+    const translateY = this.props.scrollAnimatedValue.interpolate({
+      inputRange,
+      outputRange,
+    });
+    const child = React.Children.only(this.props.children);
+
+    return (
+      <AnimatedView
+        collapsable={false}
+        onLayout={this._onLayout}
+        style={[child.props.style, styles.header, {transform: [{translateY}]}]}>
+        {React.cloneElement(child, {
+          style: styles.fill, // We transfer the child style to the wrapper.
+          onLayout: undefined, // we call this manually through our this._onLayout
+        })}
+      </AnimatedView>
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  header: {
+    zIndex: 10,
+  },
+  fill: {
+    flex: 1,
+  },
+});
+
+module.exports = ScrollViewStickyHeader;

node_modules/react-native/Libraries/Components/ScrollView/ScrollViewViewConfig.js

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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
+ */
+
+'use strict';
+
+import type {GeneratedViewConfig} from '../../Utilities/registerGeneratedViewConfig';
+
+const ScrollViewViewConfig = {
+  uiViewClassName: 'RCTScrollView',
+  bubblingEventTypes: {},
+  directEventTypes: {
+    topScrollToTop: {
+      registrationName: 'onScrollToTop',
+    },
+  },
+  validAttributes: {
+    alwaysBounceHorizontal: true,
+    alwaysBounceVertical: true,
+    automaticallyAdjustContentInsets: true,
+    bounces: true,
+    bouncesZoom: true,
+    canCancelContentTouches: true,
+    centerContent: true,
+    contentInset: {diff: require('../../Utilities/differ/pointsDiffer')},
+    contentOffset: {diff: require('../../Utilities/differ/pointsDiffer')},
+    contentInsetAdjustmentBehavior: true,
+    decelerationRate: true,
+    directionalLockEnabled: true,
+    disableIntervalMomentum: true,
+    endFillColor: {process: require('../../StyleSheet/processColor')},
+    fadingEdgeLength: true,
+    indicatorStyle: true,
+    keyboardDismissMode: true,
+    maintainVisibleContentPosition: true,
+    maximumZoomScale: true,
+    minimumZoomScale: true,
+    nestedScrollEnabled: true,
+    onMomentumScrollBegin: true,
+    onMomentumScrollEnd: true,
+    onScroll: true,
+    onScrollBeginDrag: true,
+    onScrollEndDrag: true,
+    onScrollToTop: true,
+    overScrollMode: true,
+    pagingEnabled: true,
+    persistentScrollbar: true,
+    pinchGestureEnabled: true,
+    scrollEnabled: true,
+    scrollEventThrottle: true,
+    scrollIndicatorInsets: {
+      diff: require('../../Utilities/differ/pointsDiffer'),
+    },
+    scrollPerfTag: true,
+    scrollToOverflowEnabled: true,
+    scrollsToTop: true,
+    sendMomentumEvents: true,
+    showsHorizontalScrollIndicator: true,
+    showsVerticalScrollIndicator: true,
+    snapToAlignment: true,
+    snapToEnd: true,
+    snapToInterval: true,
+    snapToOffsets: true,
+    snapToStart: true,
+    zoomScale: true,
+
+    DEPRECATED_sendUpdatedChildFrames: true,
+  },
+};
+
+module.exports = (ScrollViewViewConfig: GeneratedViewConfig);

node_modules/react-native/Libraries/Components/ScrollView/processDecelerationRate.js

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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 strict-local
+ */
+
+'use strict';
+
+const Platform = require('../../Utilities/Platform');
+
+function processDecelerationRate(
+  decelerationRate: number | 'normal' | 'fast',
+): number {
+  if (decelerationRate === 'normal') {
+    return Platform.select({
+      ios: 0.998,
+      android: 0.985,
+    });
+  } else if (decelerationRate === 'fast') {
+    return Platform.select({
+      ios: 0.99,
+      android: 0.9,
+    });
+  }
+  return decelerationRate;
+}
+
+module.exports = processDecelerationRate;