@hanzogui/react-native-web-lite 2.0.0

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

@@ -0,0 +1,137 @@
+/**
+ * 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
+ */
+
+const TouchHistoryMath = {
+  /**
+   * This code is optimized and not intended to look beautiful. This allows
+   * computing of touch centroids that have moved after `touchesChangedAfter`
+   * timeStamp. You can compute the current centroid involving all touches
+   * moves after `touchesChangedAfter`, or you can compute the previous
+   * centroid of all touches that were moved after `touchesChangedAfter`.
+   *
+   * @param {TouchHistoryMath} touchHistory Standard Responder touch track
+   * data.
+   * @param {number} touchesChangedAfter timeStamp after which moved touches
+   * are considered "actively moving" - not just "active".
+   * @param {boolean} isXAxis Consider `x` dimension vs. `y` dimension.
+   * @param {boolean} ofCurrent Compute current centroid for actively moving
+   * touches vs. previous centroid of now actively moving touches.
+   * @return {number} value of centroid in specified dimension.
+   */
+  centroidDimension: function (touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
+    const touchBank = touchHistory.touchBank
+    let total = 0
+    let count = 0
+
+    const oneTouchData =
+      touchHistory.numberActiveTouches === 1
+        ? touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch]
+        : null
+
+    if (oneTouchData !== null) {
+      if (
+        oneTouchData.touchActive &&
+        oneTouchData.currentTimeStamp > touchesChangedAfter
+      ) {
+        total +=
+          ofCurrent && isXAxis
+            ? oneTouchData.currentPageX
+            : ofCurrent && !isXAxis
+              ? oneTouchData.currentPageY
+              : !ofCurrent && isXAxis
+                ? oneTouchData.previousPageX
+                : oneTouchData.previousPageY
+        count = 1
+      }
+    } else {
+      for (let i = 0; i < touchBank.length; i++) {
+        const touchTrack = touchBank[i]
+        if (
+          touchTrack !== null &&
+          touchTrack !== undefined &&
+          touchTrack.touchActive &&
+          touchTrack.currentTimeStamp >= touchesChangedAfter
+        ) {
+          let toAdd // Yuck, program temporarily in invalid state.
+          if (ofCurrent && isXAxis) {
+            toAdd = touchTrack.currentPageX
+          } else if (ofCurrent && !isXAxis) {
+            toAdd = touchTrack.currentPageY
+          } else if (!ofCurrent && isXAxis) {
+            toAdd = touchTrack.previousPageX
+          } else {
+            toAdd = touchTrack.previousPageY
+          }
+          total += toAdd
+          count++
+        }
+      }
+    }
+    return count > 0 ? total / count : TouchHistoryMath.noCentroid
+  },
+
+  currentCentroidXOfTouchesChangedAfter: function (touchHistory, touchesChangedAfter) {
+    return TouchHistoryMath.centroidDimension(
+      touchHistory,
+      touchesChangedAfter,
+      true, // isXAxis
+      true // ofCurrent
+    )
+  },
+
+  currentCentroidYOfTouchesChangedAfter: function (touchHistory, touchesChangedAfter) {
+    return TouchHistoryMath.centroidDimension(
+      touchHistory,
+      touchesChangedAfter,
+      false, // isXAxis
+      true // ofCurrent
+    )
+  },
+
+  previousCentroidXOfTouchesChangedAfter: function (touchHistory, touchesChangedAfter) {
+    return TouchHistoryMath.centroidDimension(
+      touchHistory,
+      touchesChangedAfter,
+      true, // isXAxis
+      false // ofCurrent
+    )
+  },
+
+  previousCentroidYOfTouchesChangedAfter: function (touchHistory, touchesChangedAfter) {
+    return TouchHistoryMath.centroidDimension(
+      touchHistory,
+      touchesChangedAfter,
+      false, // isXAxis
+      false // ofCurrent
+    )
+  },
+
+  currentCentroidX: function (touchHistory) {
+    return TouchHistoryMath.centroidDimension(
+      touchHistory,
+      0, // touchesChangedAfter
+      true, // isXAxis
+      true // ofCurrent
+    )
+  },
+
+  currentCentroidY: function (touchHistory) {
+    return TouchHistoryMath.centroidDimension(
+      touchHistory,
+      0, // touchesChangedAfter
+      false, // isXAxis
+      true // ofCurrent
+    )
+  },
+
+  noCentroid: -1,
+}
+
+export { TouchHistoryMath }
+export default TouchHistoryMath

package/src/vendor/react-native/TurboModule/RCTExport.js

@@ -0,0 +1,37 @@
+/**
+ * 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'
+
+/**
+ * NOTE: This is React Native specific export type.
+ *
+ * RCTExport is an interface type that allows native code generation for React
+ * Native native modules. It exists as a hint to the codegen tool that any
+ * interface that extends it needs to be codegen'ed. Example usage:
+ *
+ *   export interface RCTFoobar extends RCTExport<void> {}
+ *
+ * Native definition for RCTFoobar will then be generated.
+ *
+ * The type param T is a placeholder for future codegen hinting, like versioning
+ * information, native base classes, etc. For now, simply use `void` type as
+ * there's nothing to give hint about.
+ */
+
+// eslint-disable-next-line no-unused-vars
+export const RCTExport = {
+  getConstants: () => ({}),
+}
+
+// eslint-disable-next-line lint/react-native-modules
+export const TurboModule = {
+  ...RCTExport,
+}

package/src/vendor/react-native/TurboModule/TurboModuleRegistry.js

@@ -0,0 +1,27 @@
+/**
+ * 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 { invariant } from '@hanzogui/react-native-web-internals'
+
+export function get(name) {
+  return null
+}
+
+export function getEnforcing(name) {
+  const module = get(name)
+  invariant(
+    module != null,
+    `TurboModuleRegistry.getEnforcing(...): '${name}' could not be found. ` +
+      'Verify that a module by this name is registered in the native binary.'
+  )
+  return module
+}

package/src/vendor/react-native/Types/CoreEventTypes.js

@@ -0,0 +1,151 @@
+/**
+ * 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'
+
+const SyntheticEvent = {
+  bubbles: null,
+  cancelable: null,
+  currentTarget: null,
+  defaultPrevented: null,
+  dispatchConfig: null,
+  eventPhase: null,
+  preventDefault: () => {},
+  isDefaultPrevented: () => false,
+  stopPropagation: () => {},
+  isPropagationStopped: () => false,
+  isTrusted: null,
+  nativeEvent: null,
+  persist: () => {},
+  target: null,
+  timeStamp: 0,
+  type: null,
+}
+
+const ResponderSyntheticEvent = {
+  ...SyntheticEvent,
+  touchHistory: null,
+}
+
+const Layout = {
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+}
+
+const TextLayout = {
+  ...Layout,
+  ascender: 0,
+  capHeight: 0,
+  descender: 0,
+  text: '',
+  xHeight: 0,
+}
+
+const LayoutEvent = {
+  layout: null,
+}
+
+const TextLayoutEvent = {
+  lines: null,
+}
+
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/API/UIEvent
+ */
+export const NativeUIEvent = {
+  detail: 0,
+}
+
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent
+ */
+export const NativeMouseEvent = {
+  screenX: 0,
+  screenY: 0,
+  pageX: 0,
+  pageY: 0,
+  clientX: 0,
+  clientY: 0,
+  x: 0,
+  y: 0,
+  ctrlKey: false,
+  shiftKey: false,
+  altKey: false,
+  metaKey: false,
+  button: 0,
+  buttons: 0,
+  relatedTarget: null,
+  offsetX: 0,
+  offsetY: 0,
+}
+
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent
+ */
+export const NativePointerEvent = {
+  ...NativeMouseEvent,
+  pointerId: 0,
+  width: 0,
+  height: 0,
+  pressure: 0,
+  tangentialPressure: 0,
+  tiltX: 0,
+  tiltY: 0,
+  twist: 0,
+  pointerType: '',
+  isPrimary: false,
+}
+
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent
+ */
+export const NativeTouchEvent = {
+  changedTouches: [],
+  identifier: 0,
+  locationX: 0,
+  locationY: 0,
+  pageX: 0,
+  pageY: 0,
+  target: null,
+  timestamp: 0,
+  touches: [],
+}
+
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent
+ */
+export const NativeKeyboardEvent = {
+  key: '',
+  code: '',
+  ctrlKey: false,
+  shiftKey: false,
+  altKey: false,
+  metaKey: false,
+  repeat: false,
+  location: 0,
+  keyCode: 0,
+  charCode: 0,
+  which: 0,
+}
+
+export const ScrollEvent = {
+  ...SyntheticEvent,
+  contentInset: { top: 0, left: 0, bottom: 0, right: 0 },
+  contentOffset: { x: 0, y: 0 },
+  contentSize: { width: 0, height: 0 },
+  layoutMeasurement: { width: 0, height: 0 },
+  velocity: { x: 0, y: 0 },
+  zoomScale: 1,
+  responderIgnoreScroll: false,
+  target: null,
+  responder: null,
+}

package/src/vendor/react-native/Utilities/Platform.js

@@ -0,0 +1,3 @@
+import { Platform } from '@hanzogui/react-native-web-internals'
+export { Platform }
+export default Platform

package/src/vendor/react-native/Utilities/clamp.js

@@ -0,0 +1,24 @@
+/**
+ * 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'
+
+function clamp(min, value, max) {
+  if (value < min) {
+    return min
+  }
+  if (value > max) {
+    return max
+  }
+  return value
+}
+
+export { clamp }
+export default clamp

package/src/vendor/react-native/Utilities/setAndForwardRef.js

@@ -0,0 +1,62 @@
+/**
+ * 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'
+
+/**
+ * This is a helper function for when a component needs to be able to forward a ref
+ * to a child component, but still needs to have access to that component as part of
+ * its implementation.
+ *
+ * Its main use case is in wrappers for native components.
+ *
+ * Usage:
+ *
+ *   class MyView extends React.Component {
+ *     _nativeRef = null;
+ *
+ *     _setNativeRef = setAndForwardRef({
+ *       getForwardedRef: () => this.props.forwardedRef,
+ *       setLocalRef: ref => {
+ *         this._nativeRef = ref;
+ *       },
+ *     });
+ *
+ *     render() {
+ *       return <View ref={this._setNativeRef} />;
+ *     }
+ *   }
+ *
+ *   const MyViewWithRef = React.forwardRef((props, ref) => (
+ *     <MyView {...props} forwardedRef={ref} />
+ *   ));
+ *
+ *   module.exports = MyViewWithRef;
+ */
+
+function setAndForwardRef({ getForwardedRef, setLocalRef }) {
+  return function forwardRef(ref) {
+    const forwardedRef = getForwardedRef()
+
+    setLocalRef(ref)
+
+    // Forward to user ref prop (if one has been specified)
+    if (typeof forwardedRef === 'function') {
+      // Handle function-based refs. String-based refs are handled as functions.
+      forwardedRef(ref)
+    } else if (typeof forwardedRef === 'object' && forwardedRef != null) {
+      // Handle createRef-based refs
+      forwardedRef.current = ref
+    }
+  }
+}
+
+export { setAndForwardRef }
+export default setAndForwardRef

package/src/vendor/react-native/Utilities/useMergeRefs.js

@@ -0,0 +1,40 @@
+/**
+ * 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
+ */
+
+import { useCallback } from 'react'
+
+/**
+ * Constructs a new ref that forwards new values to each of the given refs. The
+ * given refs will always be invoked in the order that they are supplied.
+ *
+ * WARNING: A known problem of merging refs using this approach is that if any
+ * of the given refs change, the returned callback ref will also be changed. If
+ * the returned callback ref is supplied as a `ref` to a React element, this may
+ * lead to problems with the given refs being invoked more times than desired.
+ */
+function useMergeRefs(...refs) {
+  return useCallback(
+    (current) => {
+      for (const ref of refs) {
+        if (ref != null) {
+          if (typeof ref === 'function') {
+            ref(current)
+          } else {
+            ref.current = current
+          }
+        }
+      }
+    },
+    [...refs] // eslint-disable-line react-hooks/exhaustive-deps
+  )
+}
+
+export { useMergeRefs }
+export default useMergeRefs

package/src/vendor/react-native/Utilities/useRefEffect.js

@@ -0,0 +1,44 @@
+/**
+ * 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
+ */
+
+import { useCallback, useRef } from 'react'
+
+/**
+ * Constructs a callback ref that provides similar semantics as `useEffect`. The
+ * supplied `effect` callback will be called with non-null component instances.
+ * The `effect` callback can also optionally return a cleanup function.
+ *
+ * When a component is updated or unmounted, the cleanup function is called. The
+ * `effect` callback will then be called again, if applicable.
+ *
+ * When a new `effect` callback is supplied, the previously returned cleanup
+ * function will be called before the new `effect` callback is called with the
+ * same instance.
+ *
+ * WARNING: The `effect` callback should be stable (e.g. using `useCallback`).
+ */
+function useRefEffect(effect) {
+  const cleanupRef = useRef(undefined)
+  return useCallback(
+    (instance) => {
+      if (cleanupRef.current) {
+        cleanupRef.current()
+        cleanupRef.current = undefined
+      }
+      if (instance != null) {
+        cleanupRef.current = effect(instance)
+      }
+    },
+    [effect]
+  )
+}
+
+export { useRefEffect }
+export default useRefEffect