@hanzogui/react-native-web-lite 2.0.0

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

@@ -0,0 +1,119 @@
+/**
+ * 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
+ * @format
+ */
+
+'use strict'
+
+import { Platform } from '../../../exports/Platform'
+import { UIManager } from '../../../exports/UIManager'
+
+const __DEV__ = process.env.NODE_ENV !== 'production'
+
+const Type = {
+  spring: 'spring',
+  linear: 'linear',
+  easeInEaseOut: 'easeInEaseOut',
+  easeIn: 'easeIn',
+  easeOut: 'easeOut',
+  keyboard: 'keyboard',
+}
+
+function configureNext(config, onAnimationDidEnd) {
+  if (!Platform.isTesting) {
+    UIManager.configureNextLayoutAnimation(
+      config,
+      onAnimationDidEnd ?? function () {},
+      function () {} /* unused onError */
+    )
+  }
+}
+
+function create(duration, type, property) {
+  return {
+    duration,
+    create: { type, property },
+    update: { type },
+    delete: { type, property },
+  }
+}
+
+const 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);
+ */
+const 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(...args) {
+    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 { LayoutAnimation }
+export default LayoutAnimation

package/src/vendor/react-native/PanResponder/index.js

@@ -0,0 +1,243 @@
+/**
+ * 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.
+ */
+
+import { InteractionManager } from '@hanzogui/react-native-web-internals'
+import TouchHistoryMath from '../TouchHistoryMath/index'
+
+const currentCentroidXOfTouchesChangedAfter =
+  TouchHistoryMath.currentCentroidXOfTouchesChangedAfter
+const currentCentroidYOfTouchesChangedAfter =
+  TouchHistoryMath.currentCentroidYOfTouchesChangedAfter
+const previousCentroidXOfTouchesChangedAfter =
+  TouchHistoryMath.previousCentroidXOfTouchesChangedAfter
+const previousCentroidYOfTouchesChangedAfter =
+  TouchHistoryMath.previousCentroidYOfTouchesChangedAfter
+const currentCentroidX = TouchHistoryMath.currentCentroidX
+const currentCentroidY = TouchHistoryMath.currentCentroidY
+
+const PanResponder = {
+  _initializeGestureState(gestureState) {
+    gestureState.moveX = 0
+    gestureState.moveY = 0
+    gestureState.x0 = 0
+    gestureState.y0 = 0
+    gestureState.dx = 0
+    gestureState.dy = 0
+    gestureState.vx = 0
+    gestureState.vy = 0
+    gestureState.numberActiveTouches = 0
+    gestureState._accountsForMovesUpTo = 0
+  },
+
+  _updateGestureStateOnMove(gestureState, touchHistory) {
+    gestureState.numberActiveTouches = touchHistory.numberActiveTouches
+    gestureState.moveX = currentCentroidXOfTouchesChangedAfter(
+      touchHistory,
+      gestureState._accountsForMovesUpTo
+    )
+    gestureState.moveY = currentCentroidYOfTouchesChangedAfter(
+      touchHistory,
+      gestureState._accountsForMovesUpTo
+    )
+    const movedAfter = gestureState._accountsForMovesUpTo
+    const prevX = previousCentroidXOfTouchesChangedAfter(touchHistory, movedAfter)
+    const x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter)
+    const prevY = previousCentroidYOfTouchesChangedAfter(touchHistory, movedAfter)
+    const y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter)
+    const nextDX = gestureState.dx + (x - prevX)
+    const nextDY = gestureState.dy + (y - prevY)
+
+    const dt = touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo
+    gestureState.vx = (nextDX - gestureState.dx) / dt
+    gestureState.vy = (nextDY - gestureState.dy) / dt
+
+    gestureState.dx = nextDX
+    gestureState.dy = nextDY
+    gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp
+  },
+
+  create(config) {
+    const interactionState = {
+      handle: null,
+      shouldCancelClick: false,
+      timeout: null,
+    }
+
+    const gestureState = {
+      stateID: Math.random(),
+      moveX: 0,
+      moveY: 0,
+      x0: 0,
+      y0: 0,
+      dx: 0,
+      dy: 0,
+      vx: 0,
+      vy: 0,
+      numberActiveTouches: 0,
+      _accountsForMovesUpTo: 0,
+    }
+
+    const panHandlers = {
+      onStartShouldSetResponder(event) {
+        return config.onStartShouldSetPanResponder == null
+          ? false
+          : config.onStartShouldSetPanResponder(event, gestureState)
+      },
+
+      onMoveShouldSetResponder(event) {
+        return config.onMoveShouldSetPanResponder == null
+          ? false
+          : config.onMoveShouldSetPanResponder(event, gestureState)
+      },
+
+      onStartShouldSetResponderCapture(event) {
+        if (event.nativeEvent.touches.length === 1) {
+          PanResponder._initializeGestureState(gestureState)
+        }
+        gestureState.numberActiveTouches = event.touchHistory.numberActiveTouches
+        return config.onStartShouldSetPanResponderCapture != null
+          ? config.onStartShouldSetPanResponderCapture(event, gestureState)
+          : false
+      },
+
+      onMoveShouldSetResponderCapture(event) {
+        const touchHistory = event.touchHistory
+        if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
+          return false
+        }
+        PanResponder._updateGestureStateOnMove(gestureState, touchHistory)
+        return config.onMoveShouldSetPanResponderCapture
+          ? config.onMoveShouldSetPanResponderCapture(event, gestureState)
+          : false
+      },
+
+      onResponderGrant(event) {
+        if (!interactionState.handle) {
+          interactionState.handle = InteractionManager.createInteractionHandle()
+        }
+        if (interactionState.timeout) {
+          clearInteractionTimeout(interactionState)
+        }
+        interactionState.shouldCancelClick = true
+        gestureState.x0 = currentCentroidX(event.touchHistory)
+        gestureState.y0 = currentCentroidY(event.touchHistory)
+        gestureState.dx = 0
+        gestureState.dy = 0
+        if (config.onPanResponderGrant) {
+          config.onPanResponderGrant(event, gestureState)
+        }
+        return config.onShouldBlockNativeResponder == null
+          ? true
+          : config.onShouldBlockNativeResponder(event, gestureState)
+      },
+
+      onResponderReject(event) {
+        clearInteractionHandle(
+          interactionState,
+          config.onPanResponderReject,
+          event,
+          gestureState
+        )
+      },
+
+      onResponderRelease(event) {
+        clearInteractionHandle(
+          interactionState,
+          config.onPanResponderRelease,
+          event,
+          gestureState
+        )
+        setInteractionTimeout(interactionState)
+        PanResponder._initializeGestureState(gestureState)
+      },
+
+      onResponderStart(event) {
+        const touchHistory = event.touchHistory
+        gestureState.numberActiveTouches = touchHistory.numberActiveTouches
+        if (config.onPanResponderStart) {
+          config.onPanResponderStart(event, gestureState)
+        }
+      },
+
+      onResponderMove(event) {
+        const touchHistory = event.touchHistory
+        if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
+          return
+        }
+        PanResponder._updateGestureStateOnMove(gestureState, touchHistory)
+        if (config.onPanResponderMove) {
+          config.onPanResponderMove(event, gestureState)
+        }
+      },
+
+      onResponderEnd(event) {
+        const touchHistory = event.touchHistory
+        gestureState.numberActiveTouches = touchHistory.numberActiveTouches
+        clearInteractionHandle(
+          interactionState,
+          config.onPanResponderEnd,
+          event,
+          gestureState
+        )
+      },
+
+      onResponderTerminate(event) {
+        clearInteractionHandle(
+          interactionState,
+          config.onPanResponderTerminate,
+          event,
+          gestureState
+        )
+        setInteractionTimeout(interactionState)
+        PanResponder._initializeGestureState(gestureState)
+      },
+
+      onResponderTerminationRequest(event) {
+        return config.onPanResponderTerminationRequest == null
+          ? true
+          : config.onPanResponderTerminationRequest(event, gestureState)
+      },
+
+      onClickCapture: (event) => {
+        if (interactionState.shouldCancelClick === true) {
+          event.stopPropagation()
+          event.preventDefault()
+        }
+      },
+    }
+
+    return {
+      panHandlers,
+      getInteractionHandle() {
+        return interactionState.handle
+      },
+    }
+  },
+}
+
+function clearInteractionHandle(interactionState, callback, event, gestureState) {
+  if (interactionState.handle) {
+    InteractionManager.clearInteractionHandle(interactionState.handle)
+    interactionState.handle = null
+  }
+  if (callback) {
+    callback(event, gestureState)
+  }
+}
+
+function clearInteractionTimeout(interactionState) {
+  clearTimeout(interactionState.timeout)
+}
+
+function setInteractionTimeout(interactionState) {
+  interactionState.timeout = setTimeout(() => {
+    interactionState.shouldCancelClick = false
+  }, 250)
+}
+
+export { PanResponder }
+export default PanResponder

package/src/vendor/react-native/PooledClass/index.js

@@ -0,0 +1,62 @@
+/* eslint-disable */
+
+/**
+ * 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.
+ *
+ * From React 16.0.0
+ */
+
+var twoArgumentPooler = function (a1, a2) {
+  var Klass = this
+  if (Klass.instancePool.length) {
+    var instance = Klass.instancePool.pop()
+    Klass.call(instance, a1, a2)
+    return instance
+  } else {
+    return new Klass(a1, a2)
+  }
+}
+
+var standardReleaser = function (instance) {
+  var Klass = this
+  instance.destructor()
+  if (Klass.instancePool.length < Klass.poolSize) {
+    Klass.instancePool.push(instance)
+  }
+}
+
+var DEFAULT_POOL_SIZE = 10
+var DEFAULT_POOLER = twoArgumentPooler
+
+/**
+ * Augments `CopyConstructor` to be a poolable class, augmenting only the class
+ * itself (statically) not adding any prototypical fields. Any CopyConstructor
+ * you give this may have a `poolSize` property, and will look for a
+ * prototypical `destructor` on instances.
+ *
+ * @param {Function} CopyConstructor Constructor that can be used to reset.
+ * @param {Function} pooler Customizable pooler.
+ */
+var addPoolingTo = function (CopyConstructor, pooler) {
+  // Casting as any so that flow ignores the actual implementation and trusts
+  // it to match the type we declared
+  var NewKlass = CopyConstructor
+  NewKlass.instancePool = []
+  NewKlass.getPooled = pooler || DEFAULT_POOLER
+  if (!NewKlass.poolSize) {
+    NewKlass.poolSize = DEFAULT_POOL_SIZE
+  }
+  NewKlass.release = standardReleaser
+  return NewKlass
+}
+
+var PooledClass = {
+  addPoolingTo: addPoolingTo,
+  twoArgumentPooler: twoArgumentPooler,
+}
+
+export { PooledClass }
+export default PooledClass

package/src/vendor/react-native/ReactNative/ReactNativeFeatureFlags.js

@@ -0,0 +1,20 @@
+/**
+ * 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
+ * @format
+ */
+
+const ReactNativeFeatureFlags = {
+  isLayoutAnimationEnabled: () => true,
+  shouldEmitW3CPointerEvents: () => false,
+  shouldPressibilityUseW3CPointerEventsForHover: () => false,
+  animatedShouldDebounceQueueFlush: () => false,
+  animatedShouldUseSingleOp: () => false,
+}
+
+export { ReactNativeFeatureFlags }
+export default ReactNativeFeatureFlags

package/src/vendor/react-native/SHA

@@ -0,0 +1,2 @@
+facebook/react-native@0.60.0-rc.3
+facebook/react-native@8a43321271bd58bbe0bca27593e121077d7a4065

package/src/vendor/react-native/SectionList/index.jsx

@@ -0,0 +1,100 @@
+/**
+ * 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.
+ */
+
+import { VirtualizedSectionList } from '../VirtualizedSectionList'
+import * as React from 'react'
+
+class SectionList extends React.PureComponent {
+  scrollToLocation(params) {
+    if (this._wrapperListRef != null) {
+      this._wrapperListRef.scrollToLocation(params)
+    }
+  }
+
+  recordInteraction() {
+    const listRef = this._wrapperListRef && this._wrapperListRef.getListRef()
+    listRef && listRef.recordInteraction()
+  }
+
+  flashScrollIndicators() {
+    const listRef = this._wrapperListRef && this._wrapperListRef.getListRef()
+    listRef && listRef.flashScrollIndicators()
+  }
+
+  getScrollResponder() {
+    const listRef = this._wrapperListRef && this._wrapperListRef.getListRef()
+    if (listRef) {
+      return listRef.getScrollResponder()
+    }
+  }
+
+  getScrollableNode() {
+    const listRef = this._wrapperListRef && this._wrapperListRef.getListRef()
+    if (listRef) {
+      return listRef.getScrollableNode()
+    }
+  }
+
+  setNativeProps(props) {
+    const listRef = this._wrapperListRef && this._wrapperListRef.getListRef()
+    if (listRef) {
+      listRef.setNativeProps(props)
+    }
+  }
+
+  render() {
+    const { sections, ...passThroughProps } = this.props
+    return (
+      <VirtualizedSectionList
+        {...passThroughProps}
+        sections={sections}
+        ref={this._captureRef}
+        getItem={this._getItem}
+        getItemCount={this._getItemCount}
+        keyExtractor={this._keyExtractor}
+        renderItem={this._renderItem}
+      />
+    )
+  }
+
+  _captureRef = (ref) => {
+    this._wrapperListRef = ref
+  }
+
+  _getItem = (sections, index) => {
+    if (!sections) {
+      return null
+    }
+    const section = sections[index]
+    return section && section.data ? section.data[0] : null
+  }
+
+  _getItemCount = (sections) => {
+    return sections ? sections.length : 0
+  }
+
+  _keyExtractor = (item, index) => {
+    const keyExtractor = this.props.keyExtractor || this._defaultKeyExtractor
+    return keyExtractor(item, index)
+  }
+
+  _defaultKeyExtractor = (item, index) => {
+    return item.key != null ? item.key : String(index)
+  }
+
+  _renderItem = ({ item, index, section }) => {
+    const renderItem = this.props.renderItem || this._defaultRenderItem
+    return renderItem({ item, index, section })
+  }
+
+  _defaultRenderItem = ({ item }) => {
+    return null
+  }
+}
+
+export { SectionList }
+export default SectionList

package/src/vendor/react-native/StaticContainer/index.js

@@ -0,0 +1,43 @@
+/**
+ * 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
+ * @format
+ */
+
+'use strict'
+
+import * as React from 'react'
+
+/**
+ * Renders static content efficiently by allowing React to short-circuit the
+ * reconciliation process. This component should be used when you know that a
+ * subtree of components will never need to be updated.
+ *
+ *   const someValue = ...; // We know for certain this value will never change.
+ *   return (
+ *     <StaticContainer>
+ *       <MyComponent value={someValue} />
+ *     </StaticContainer>
+ *   );
+ *
+ * Typically, you will not need to use this component and should opt for normal
+ * React reconciliation.
+ */
+
+class StaticContainer extends React.Component {
+  shouldComponentUpdate(nextProps) {
+    return !!nextProps.shouldUpdate
+  }
+
+  render() {
+    const child = this.props.children
+    return child === null || child === false ? null : React.Children.only(child)
+  }
+}
+
+export { StaticContainer }
+export default StaticContainer

package/src/vendor/react-native/StaticRenderer/index.js

@@ -0,0 +1,26 @@
+/**
+ * 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
+ * @format
+ */
+
+'use strict'
+
+import * as React from 'react'
+
+class StaticRenderer extends React.Component {
+  shouldComponentUpdate(nextProps) {
+    return nextProps.shouldUpdate
+  }
+
+  render() {
+    return this.props.render()
+  }
+}
+
+export { StaticRenderer }
+export default StaticRenderer