react-native-reanimated 2.10.0 → 2.11.0

package/lib/types/reanimated2/utils.d.ts

@@ -4,4 +4,8 @@ export interface ComponentCoords {
     x: number;
     y: number;
 }
-export declare function getRelativeCoords(parentRef: RefObjectFunction<Component>, x: number, y: number): ComponentCoords;
+/**
+ * Given an absolute position and a component ref, returns the relative
+ * position in the component's local coordinate space.
+ */
+export declare function getRelativeCoords(parentRef: RefObjectFunction<Component>, absoluteX: number, absoluteY: number): ComponentCoords | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-reanimated",
-  "version": "2.10.0",
+  "version": "2.11.0",
   "description": "More powerful alternative to Animated library for React Native.",
   "scripts": {
     "test": "yarn run format:js && yarn run lint:js && yarn run test:unit",
@@ -50,6 +50,7 @@
     "!ios/build/",
     "!android/build/",
     "RNReanimated.podspec",
+    "scripts/reanimated_utils.rb",
     "README.md",
     "react-native-reanimated.d.ts",
     "mock.js",
@@ -93,7 +94,7 @@
     "@react-native-community/bob": "^0.17.1",
     "@react-native-community/eslint-config": "^0.0.5",
     "@testing-library/jest-native": "^4.0.4",
-    "@testing-library/react-hooks": "^5.0.3",
+    "@testing-library/react-hooks": "^8.0.0",
     "@testing-library/react-native": "^7.1.0",
     "@types/babel-types": "^7.0.11",
     "@types/babel__core": "^7.1.18",
@@ -121,11 +122,11 @@
     "madge": "^5.0.1",
     "prettier": "^2.5.1",
     "react": "17.0.2",
-    "react-native": "0.70.0-rc.3",
+    "react-native": "0.70.2",
     "react-native-builder-bob": "^0.18.3",
     "react-native-codegen": "^0.0.7",
     "react-native-gesture-handler": "^1.6.1",
-    "react-test-renderer": "18.0.0",
+    "react-test-renderer": "17.0.2",
     "release-it": "^13.7.2",
     "typescript": "^4.1.3"
   },

package/plugin.js

@@ -447,7 +447,7 @@ function makeWorklet(t, fun, state) {
   const workletHash = hash(funString);
 
   let location = state.file.opts.filename;
-  if (state.opts.relativeSourceLocation) {
+  if (state.opts && state.opts.relativeSourceLocation) {
     const path = require('path');
     location = path.relative(state.cwd, location);
   }

package/react-native-reanimated.d.ts

@@ -54,6 +54,8 @@ declare module 'react-native-reanimated' {
     import('./lib/types/lib/reanimated2/animation/index').StyleLayoutAnimation;
   export type Animation<T> =
     import('./lib/types/lib/reanimated2/commonTypes').Animation<T>;
+  export type MeasuredDimensions =
+    import('./lib/types/lib/reanimated2/commonTypes').MeasuredDimensions;
 
   namespace Animated {
     type Nullable<T> = T | null | undefined;
@@ -543,8 +545,13 @@ declare module 'react-native-reanimated' {
     isActive: boolean;
     callbackId: number;
   };
+  export type FrameInfo = {
+    timestamp: number;
+    timeSincePreviousFrame: number | null;
+    timeSinceFirstFrame: number;
+  };
   export function useFrameCallback(
-    callback: () => void,
+    callback: (frameInfo: FrameInfo) => void,
     autostart?: boolean
   ): FrameCallback;
 
@@ -561,6 +568,10 @@ declare module 'react-native-reanimated' {
   };
   export function useAnimatedKeyboard(): AnimatedKeyboardInfo;
 
+  export function useScrollViewOffset(
+    aref: RefObject<Animated.ScrollView>
+  ): SharedValue<number>;
+
   export interface ExitAnimationsValues {
     currentOriginX: number;
     currentOriginY: number;
@@ -803,14 +814,7 @@ declare module 'react-native-reanimated' {
   export function defineAnimation<T>(starting: any, factory: () => T): number;
   export function measure<T extends Component>(
     ref: RefObject<T>
-  ): {
-    width: number;
-    height: number;
-    x: number;
-    y: number;
-    pageX: number;
-    pageY: number;
-  };
+  ): MeasuredDimensions | null;
 
   export function getRelativeCoords(
     ref: RefObject<Component>,

package/scripts/reanimated_utils.rb

@@ -0,0 +1,65 @@
+def try_to_parse_react_native_package_json(node_modules_dir)
+  react_native_package_json_path = File.join(node_modules_dir, 'react-native/package.json')
+  if !File.exists?(react_native_package_json_path)
+    return nil
+  end
+  return JSON.parse(File.read(react_native_package_json_path))
+end
+
+def find_config()
+  result = {
+    :is_reanimated_example_app => nil,
+    :react_native_version => nil,
+    :react_native_minor_version => nil,
+    :is_tvos_target => nil,
+    :react_native_node_modules_dir => nil,
+    :reanimated_node_modules_dir => nil,
+    :react_native_common_dir => nil,
+  }
+
+  react_native_node_modules_dir = File.join(File.dirname(`cd #{Pod::Config.instance.installation_root.to_s} && node --print "require.resolve('react-native/package.json')"`), '..')
+  react_native_json = try_to_parse_react_native_package_json(react_native_node_modules_dir)
+
+  if react_native_json == nil
+    # user configuration, just in case
+    node_modules_dir = ENV["REACT_NATIVE_NODE_MODULES_DIR"]
+    react_native_json = try_to_parse_react_native_package_json(node_modules_dir)
+  end
+
+  if react_native_json == nil
+    raise '[RNReanimated] Unable to recognize your `react-native` version! Please set environmental variable with `react-native` locations: `export REACT_NATIVE_NODE_MODULES_DIR="<path to react-native>" && pod install'
+  end
+
+  result[:is_reanimated_example_app] = ENV["REANIMATED_EXAMPLE_APP_NAME"] != nil
+  result[:is_tvos_target] = react_native_json['name'] == 'react-native-tvos'
+  result[:react_native_version] = react_native_json['version']
+  result[:react_native_minor_version] = react_native_json['version'].split('.')[1].to_i
+  result[:react_native_node_modules_dir] = File.expand_path(react_native_node_modules_dir)
+  result[:reanimated_node_modules_dir] = File.expand_path(File.join(__dir__, '..', '..'))
+  result[:react_native_common_dir] = File.join(react_native_node_modules_dir, 'react-native', 'ReactCommon')
+
+  return result
+end
+
+def assert_no_multiple_instances(react_native_info)
+  if react_native_info[:is_reanimated_example_app]
+    return
+  end
+
+  lib_instances_in_react_native_node_modules = %x[find #{react_native_info[:react_native_node_modules_dir]} -name "package.json" | grep "/react-native-reanimated/package.json"]
+  lib_instances_in_react_native_node_modules_array = lib_instances_in_react_native_node_modules.split("\n")
+  reanimated_instances = lib_instances_in_react_native_node_modules_array.length()
+  if react_native_info[:react_native_node_modules_dir] != react_native_info[:reanimated_node_modules_dir]
+    lib_instances_in_reanimated_node_modules = %x[find #{react_native_info[:reanimated_node_modules_dir]} -name "package.json" | grep "/react-native-reanimated/package.json"]
+    lib_instances_in_reanimated_node_modules_array = lib_instances_in_reanimated_node_modules.split("\n")
+    reanimated_instances += lib_instances_in_reanimated_node_modules_array.length()
+  end
+  if reanimated_instances > 1
+    parsed_location = ''
+    for location in lib_instances_in_react_native_node_modules_array + lib_instances_in_reanimated_node_modules_array
+      location['/package.json'] = ''
+      parsed_location += "- " + location + "\n"
+    end
+    raise "[Reanimated] Multiple versions of Reanimated were detected. Only one instance of react-native-reanimated can be installed in a project. You need to resolve the conflict manually. Check out the documentation: https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/troubleshooting#multiple-versions-of-reanimated-were-detected \n\nConflict between: \n" + parsed_location
+  end
+end

package/src/index.web.ts

@@ -1,5 +1,7 @@
 // tree-shaken side effects
 import './reanimated2/js-reanimated/global';
 
+// @ts-ignore backward compatibility with treeshaking
+export * from './reanimated1';
 export * from './reanimated2';
 export * as default from './Animated'; // If this line fails, you probably forgot some installation steps. Check out the installation guide here: https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation/ 1) Make sure reanimated's babel plugin is installed in your babel.config.js (you should have 'react-native-reanimated/plugin' listed there - also see the above link for details) 2) Make sure you reset build cache after updating the config, run: yarn start --reset-cache

package/src/reanimated2/NativeMethods.ts

@@ -1,9 +1,8 @@
 /* global _WORKLET _measure _scrollTo _setGestureState */
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
 import { Component } from 'react';
 import { findNodeHandle } from 'react-native';
-import { RefObjectFunction } from './commonTypes';
+import { MeasuredDimensions } from './commonTypes';
+import { RefObjectFunction } from './hook/commonTypes';
 import { shouldBeUseWeb } from './PlatformChecker';
 
 export function getTag(
@@ -12,45 +11,58 @@ export function getTag(
   return findNodeHandle(view);
 }
 
-export interface MeasuredDimensions {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  pageX: number;
-  pageY: number;
-}
-
-const isNativeIndefined = shouldBeUseWeb();
+const isNative = !shouldBeUseWeb();
 
 export function measure(
   animatedRef: RefObjectFunction<Component>
-): MeasuredDimensions {
+): MeasuredDimensions | null {
   'worklet';
-  if (!_WORKLET || isNativeIndefined) {
+  if (!isNative) {
     console.warn(
-      '[reanimated.measure] method cannot be used for web or Chrome Debugger'
+      '[Reanimated] measure() cannot be used on web or Chrome Debugger'
     );
-    return {
-      x: NaN,
-      y: NaN,
-      width: NaN,
-      height: NaN,
-      pageX: NaN,
-      pageY: NaN,
-    };
+    return null;
   }
+
+  if (!_WORKLET) {
+    console.warn(
+      '[Reanimated] measure() was called from the main JS context. Measure is ' +
+        'only available in the UI runtime. This may also happen if measure() ' +
+        'was called by a worklet in the useAnimatedStyle hook, because useAnimatedStyle ' +
+        'calls the given worklet on the JS runtime during render. If you want to ' +
+        'prevent this warning then wrap the call with `if (_WORKLET)`. Then it will ' +
+        'only be called on the UI runtime after the render has been completed.'
+    );
+    return null;
+  }
+
   const viewTag = animatedRef();
-  const result = _measure(viewTag);
-  if (result.x === -1234567) {
-    throw new Error(`The view with tag ${viewTag} could not be measured`);
+  if (viewTag === -1) {
+    console.warn(
+      `[Reanimated] The view with tag ${viewTag} is not a valid argument for measure(). This may be because the view is not currently rendered, which may not be a bug (e.g. an off-screen FlatList item).`
+    );
+    return null;
   }
-  if (isNaN(result.x)) {
+
+  const measured = _measure(viewTag);
+  if (measured === null) {
+    console.warn(
+      `[Reanimated] The view with tag ${viewTag} has some undefined, not-yet-computed or meaningless value of \`LayoutMetrics\` type. This may be because the view is not currently rendered, which may not be a bug (e.g. an off-screen FlatList item).`
+    );
+    return null;
+  } else if (measured.x === -1234567) {
+    console.warn(
+      `[Reanimated] The view with tag ${viewTag} returned an invalid measurement response`
+    );
+    return null;
+  } else if (isNaN(measured.x)) {
     console.warn(
-      'Trying to measure a component which gets view-flattened on Android. To disable view-flattening, set `collapsable={false}` on this component.'
+      `[Reanimated] The view with tag ${viewTag} gets view-flattened on Android. To disable view-flattening, set \`collapsable={false}\` on this component.`
     );
+    return null;
+  } else {
+    return measured;
   }
-  return result;
 }
 
 export function scrollTo(
@@ -60,7 +72,7 @@ export function scrollTo(
   animated: boolean
 ): void {
   'worklet';
-  if (!_WORKLET || isNativeIndefined) {
+  if (!_WORKLET || !isNative) {
     return;
   }
   const viewTag = animatedRef();
@@ -69,7 +81,7 @@ export function scrollTo(
 
 export function setGestureState(handlerTag: number, newState: number): void {
   'worklet';
-  if (!_WORKLET || isNativeIndefined) {
+  if (!_WORKLET || !isNative) {
     console.warn(
       '[Reanimated] You can not use setGestureState in non-worklet function.'
     );

package/src/reanimated2/commonTypes.ts

@@ -160,3 +160,12 @@ export type AnimatedKeyboardInfo = {
   height: SharedValue<number>;
   state: SharedValue<KeyboardState>;
 };
+
+export interface MeasuredDimensions {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  pageX: number;
+  pageY: number;
+}

package/src/reanimated2/frameCallback/FrameCallbackRegistryJS.ts

@@ -1,5 +1,5 @@
 import { runOnUI } from '../core';
-import { prepareUIRegistry } from './FrameCallbackRegistryUI';
+import { FrameInfo, prepareUIRegistry } from './FrameCallbackRegistryUI';
 
 export default class FrameCallbackRegistryJS {
   private nextCallbackId = 0;
@@ -8,7 +8,7 @@ export default class FrameCallbackRegistryJS {
     prepareUIRegistry();
   }
 
-  registerFrameCallback(callback: () => void): number {
+  registerFrameCallback(callback: (frameInfo: FrameInfo) => void): number {
     if (!callback) {
       return -1;
     }
@@ -24,20 +24,17 @@ export default class FrameCallbackRegistryJS {
     return callbackId;
   }
 
-  unregisterFrameCallback(frameCallbackId: number): void {
+  unregisterFrameCallback(callbackId: number): void {
     runOnUI(() => {
       'worklet';
-      global._frameCallbackRegistry.unregisterFrameCallback(frameCallbackId);
+      global._frameCallbackRegistry.unregisterFrameCallback(callbackId);
     })();
   }
 
-  manageStateFrameCallback(frameCallbackId: number, state: boolean): void {
+  manageStateFrameCallback(callbackId: number, state: boolean): void {
     runOnUI(() => {
       'worklet';
-      global._frameCallbackRegistry.manageStateFrameCallback(
-        frameCallbackId,
-        state
-      );
+      global._frameCallbackRegistry.manageStateFrameCallback(callbackId, state);
     })();
   }
 }

package/src/reanimated2/frameCallback/FrameCallbackRegistryUI.ts

@@ -1,61 +1,112 @@
 import { runOnUI } from '../core';
 
-export default interface FrameCallbackRegistryUI {
-  frameCallbackRegistry: Map<number, () => void>;
-  frameCallbackActive: Set<number>;
-  isFrameCallbackRunning: boolean;
+type CallbackDetails = {
+  callback: (frameInfo: FrameInfo) => void;
+  startTime: number | null;
+};
+
+export type FrameInfo = {
+  timestamp: number;
+  timeSincePreviousFrame: number | null;
+  timeSinceFirstFrame: number;
+};
+
+interface FrameCallbackRegistryUI {
+  frameCallbackRegistry: Map<number, CallbackDetails>;
+  activeFrameCallbacks: Set<number>;
+  previousFrameTimestamp: number | null;
   runCallbacks: () => void;
-  registerFrameCallback: (callback: () => void, callbackId: number) => void;
-  unregisterFrameCallback: (frameCallbackId: number) => void;
-  manageStateFrameCallback: (frameCallbackId: number, state: boolean) => void;
+  registerFrameCallback: (
+    callback: (frameInfo: FrameInfo) => void,
+    callbackId: number
+  ) => void;
+  unregisterFrameCallback: (callbackId: number) => void;
+  manageStateFrameCallback: (callbackId: number, state: boolean) => void;
 }
 
 export const prepareUIRegistry = runOnUI(() => {
   'worklet';
 
   const frameCallbackRegistry: FrameCallbackRegistryUI = {
-    frameCallbackRegistry: new Map<number, () => void>(),
-    frameCallbackActive: new Set<number>(),
-    isFrameCallbackRunning: false,
+    frameCallbackRegistry: new Map<number, CallbackDetails>(),
+    activeFrameCallbacks: new Set<number>(),
+    previousFrameTimestamp: null,
 
     runCallbacks() {
-      const loop = () => {
-        this.frameCallbackActive.forEach((key: number) => {
-          const callback = this.frameCallbackRegistry.get(key);
-          callback!();
+      const loop = (timestamp: number) => {
+        if (this.previousFrameTimestamp === null) {
+          this.previousFrameTimestamp = timestamp;
+        }
+
+        const delta = timestamp - this.previousFrameTimestamp;
+
+        this.activeFrameCallbacks.forEach((callbackId: number) => {
+          const callbackDetails = this.frameCallbackRegistry.get(callbackId)!;
+
+          const { startTime } = callbackDetails;
+
+          if (startTime === null) {
+            // First frame
+            callbackDetails.startTime = timestamp;
+
+            callbackDetails.callback({
+              timestamp,
+              timeSincePreviousFrame: null,
+              timeSinceFirstFrame: 0,
+            });
+          } else {
+            // Next frame
+            callbackDetails.callback({
+              timestamp,
+              timeSincePreviousFrame: delta,
+              timeSinceFirstFrame: timestamp - startTime,
+            });
+          }
         });
 
-        if (this.frameCallbackActive.size > 0) {
+        if (this.activeFrameCallbacks.size > 0) {
+          this.previousFrameTimestamp = timestamp;
           requestAnimationFrame(loop);
         } else {
-          this.isFrameCallbackRunning = false;
+          this.previousFrameTimestamp = null;
         }
       };
 
-      if (!this.isFrameCallbackRunning) {
+      // runCallback() should only be called after registering a callback,
+      // so if there is only one active callback, then it means that there were
+      // zero previously and the loop isn't running yet.
+      if (this.activeFrameCallbacks.size === 1) {
         requestAnimationFrame(loop);
-        this.isFrameCallbackRunning = true;
       }
     },
 
-    registerFrameCallback(callback: () => void, callbackId: number) {
-      this.frameCallbackRegistry.set(callbackId, callback);
+    registerFrameCallback(
+      callback: (frameInfo: FrameInfo) => void,
+      callbackId: number
+    ) {
+      this.frameCallbackRegistry.set(callbackId, {
+        callback: callback,
+        startTime: null,
+      });
     },
 
-    unregisterFrameCallback(frameCallbackId: number) {
-      this.manageStateFrameCallback(frameCallbackId, false);
-      this.frameCallbackRegistry.delete(frameCallbackId);
+    unregisterFrameCallback(callbackId: number) {
+      this.manageStateFrameCallback(callbackId, false);
+      this.frameCallbackRegistry.delete(callbackId);
     },
 
-    manageStateFrameCallback(frameCallbackId: number, state: boolean) {
-      if (frameCallbackId === -1) {
+    manageStateFrameCallback(callbackId: number, state: boolean) {
+      if (callbackId === -1) {
         return;
       }
       if (state) {
-        this.frameCallbackActive.add(frameCallbackId);
+        this.activeFrameCallbacks.add(callbackId);
         this.runCallbacks();
       } else {
-        this.frameCallbackActive.delete(frameCallbackId);
+        const callback = this.frameCallbackRegistry.get(callbackId)!;
+        callback.startTime = null;
+
+        this.activeFrameCallbacks.delete(callbackId);
       }
     },
   };

package/src/reanimated2/globals.d.ts

@@ -20,7 +20,7 @@ declare global {
     name: string,
     updates: StyleProps | AnimatedStyle
   ) => void;
-  const _measure: (viewTag: number) => MeasuredDimensions;
+  const _measure: (viewTag: number) => MeasuredDimensions | null;
   const _scrollTo: (
     viewTag: number,
     x: number,
@@ -40,7 +40,7 @@ declare global {
       _WORKLET: boolean;
       __reanimatedModuleProxy: NativeReanimated;
       _frameTimestamp: number | null;
-      _measure: () => MeasuredDimensions;
+      _measure: () => MeasuredDimensions | null;
       _scrollTo: () => void;
       _chronoNow: () => number;
       performance: { now: () => number };

package/src/reanimated2/hook/index.ts

@@ -27,3 +27,4 @@ export { useAnimatedSensor, SensorType } from './useAnimatedSensor';
 export { useFrameCallback } from './useFrameCallback';
 export type { FrameCallback } from './useFrameCallback';
 export { useAnimatedKeyboard } from './useAnimatedKeyboard';
+export { useScrollViewOffset } from './useScrollViewOffset';

package/src/reanimated2/hook/useAnimatedScrollHandler.ts

@@ -10,7 +10,9 @@ export interface ScrollHandler<TContext extends Context>
   (event: NativeScrollEvent, context?: TContext): void;
 }
 
-interface ScrollEvent extends NativeScrollEvent, NativeEvent<ScrollEvent> {
+export interface ScrollEvent
+  extends NativeScrollEvent,
+    NativeEvent<ScrollEvent> {
   eventName: string;
 }
 export interface ScrollHandlers<TContext extends Context> {

package/src/reanimated2/hook/useFrameCallback.ts

@@ -1,5 +1,6 @@
 import { useEffect, useRef } from 'react';
 import FrameCallbackRegistryJS from '../frameCallback/FrameCallbackRegistryJS';
+import { FrameInfo } from '../frameCallback/FrameCallbackRegistryUI';
 
 export type FrameCallback = {
   setActive: (isActive: boolean) => void;
@@ -9,7 +10,7 @@ export type FrameCallback = {
 const frameCallbackRegistry = new FrameCallbackRegistryJS();
 
 export function useFrameCallback(
-  callback: () => void,
+  callback: (frameInfo: FrameInfo) => void,
   autostart = true
 ): FrameCallback {
   const ref = useRef<FrameCallback>({

package/src/reanimated2/hook/useScrollViewOffset.ts

@@ -0,0 +1,36 @@
+import { RefObject, useEffect, useRef } from 'react';
+
+import { findNodeHandle } from 'react-native';
+import type Animated from 'react-native-reanimated';
+import { useEvent, useSharedValue } from '.';
+import { SharedValue } from '../commonTypes';
+import { ScrollEvent } from './useAnimatedScrollHandler';
+
+const subscribeForEvents = [
+  'onScroll',
+  'onScrollBeginDrag',
+  'onScrollEndDrag',
+  'onMomentumScrollBegin',
+  'onMomentumScrollEnd',
+];
+
+export function useScrollViewOffset(
+  aref: RefObject<Animated.ScrollView>
+): SharedValue<number> {
+  const offsetRef = useRef(useSharedValue(0));
+
+  const event = useEvent<ScrollEvent>((event: ScrollEvent) => {
+    'worklet';
+    offsetRef.current.value =
+      event.contentOffset.x === 0
+        ? event.contentOffset.y
+        : event.contentOffset.x;
+  }, subscribeForEvents);
+
+  useEffect(() => {
+    const viewTag = findNodeHandle(aref.current);
+    event.current?.registerForEvents(viewTag as number);
+  }, [aref.current]);
+
+  return offsetRef.current;
+}

package/src/reanimated2/utils.ts

@@ -7,15 +7,22 @@ export interface ComponentCoords {
   y: number;
 }
 
+/**
+ * Given an absolute position and a component ref, returns the relative
+ * position in the component's local coordinate space.
+ */
 export function getRelativeCoords(
   parentRef: RefObjectFunction<Component>,
-  x: number,
-  y: number
-): ComponentCoords {
+  absoluteX: number,
+  absoluteY: number
+): ComponentCoords | null {
   'worklet';
   const parentCoords = measure(parentRef);
+  if (parentCoords === null) {
+    return null;
+  }
   return {
-    x: x - parentCoords.x,
-    y: y - parentCoords.y,
+    x: absoluteX - parentCoords.x,
+    y: absoluteY - parentCoords.y,
   };
 }

package/android/src/main/java/com/swmansion/reanimated/AndroidErrorHandler.java

@@ -1,8 +0,0 @@
-package com.swmansion.reanimated;
-
-public class AndroidErrorHandler {
-
-  public static void raise(String message) {
-    throw new RuntimeException(message);
-  }
-}

package/lib/reanimated2/__mocks__/NativeReanimated.native.js

@@ -1,20 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-import MutableValue from './MutableValue';
-global._setGlobalConsole = (_val) => {
-    // noop
-};
-const NOOP = () => {
-    // noop
-};
-export default {
-    installCoreFunctions: NOOP,
-    makeShareable: (worklet) => worklet,
-    makeMutable: (init) => new MutableValue(init),
-    makeRemote: NOOP,
-    startMapper: NOOP,
-    stopMapper: NOOP,
-    registerEventHandler: NOOP,
-    unregisterEventHandler: NOOP,
-    getViewProp: NOOP,
-};