react-native-reanimated 3.0.2 → 3.1.0

package/lib/module/reanimated2/shareables.js

@@ -1,20 +1,18 @@
 import NativeReanimatedModule from './NativeReanimated';
 import { shouldBeUseWeb } from './PlatformChecker';
-import { registerWorkletStackDetails } from './errors'; // for web/chrome debugger/jest environments this file provides a stub implementation
+import { registerWorkletStackDetails } from './errors';
+import { jsVersion } from './platform-specific/jsVersion';
+
+// for web/chrome debugger/jest environments this file provides a stub implementation
 // where no shareable references are used. Instead, the objects themselves are used
 // instead of shareable references, because of the fact that we don't have to deal with
 // runnning the code on separate VMs.
-
 const USE_STUB_IMPLEMENTATION = shouldBeUseWeb();
-
-const _shareableCache = new WeakMap(); // the below symbol is used to represent a mapping from the value to itself
+const _shareableCache = new WeakMap();
+// the below symbol is used to represent a mapping from the value to itself
 // this is used to allow for a converted shareable to be passed to makeShareableClone
-
-
 const _shareableFlag = Symbol('shareable flag');
-
 const MAGIC_KEY = 'REANIMATED_MAGIC_KEY';
-
 function isHostObject(value) {
   // We could use JSI to determine whether an object is a host object, however
   // the below workaround works well and is way faster than an additional JSI call.
@@ -22,37 +20,89 @@ function isHostObject(value) {
   // and hence return true for all `in` checks regardless of the key we ask for.
   return MAGIC_KEY in value;
 }
-
 export function registerShareableMapping(shareable, shareableRef) {
   if (USE_STUB_IMPLEMENTATION) {
     return;
   }
-
   _shareableCache.set(shareable, shareableRef || _shareableFlag);
 }
+function isPlainJSObject(object) {
+  return Object.getPrototypeOf(object) === Object.prototype;
+}
+
+// The below object is used as a replacement for objects that cannot be transferred
+// as shareable values. In makeShareableCloneRecursive we detect if an object is of
+// a plain Object.prototype and only allow such objects to be transferred. This lets
+// us avoid all sorts of react internals from leaking into the UI runtime. To make it
+// possible to catch errors when someone actually tries to access such object on the UI
+// runtime, we use the below Proxy object which is instantiated on the UI runtime and
+// throws whenever someone tries to access its fields.
+const INACCESSIBLE_OBJECT = {
+  __init: () => {
+    'worklet';
+
+    return new Proxy({}, {
+      get: (_, prop) => {
+        if (prop === '_isReanimatedSharedValue') {
+          // not very happy about this check here, but we need to allow for
+          // "inaccessible" objects to be tested with isSharedValue check
+          // as it is being used in the mappers when extracing inputs recursively.
+          // Apparently we can't check if a key exists there as HostObjects always
+          // return true for such tests, so the only possibility for us is to
+          // actually access that key and see if it is set to true. We therefore
+          // need to allow for this key to be accessed here.
+          return false;
+        }
+        throw new Error(`Trying to access property \`${prop}\` of an object which cannot be sent to the UI runtime.`);
+      },
+      set: () => {
+        throw new Error('Trying to write to an object which cannot be sent to the UI runtime.');
+      }
+    });
+  }
+};
+const DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD = 30;
+// Below variable stores object that we process in makeShareableCloneRecursive at the specified depth.
+// We use it to check if later on the function reenters with the same object
+let processedObjectAtThresholdDepth;
+
+// We only want to show mismatch error once so we use this flag to track it
+let didShowPluginVersionMismatchError = false;
 export function makeShareableCloneRecursive(value) {
   let shouldPersistRemote = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-
+  let depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
   if (USE_STUB_IMPLEMENTATION) {
     return value;
-  } // This one actually may be worth to be moved to c++, we also need similar logic to run on the UI thread
-
-
+  }
+  if (depth >= DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD) {
+    // if we reach certain recursion depth we suspect that we are dealing with a cyclic object.
+    // this type of objects are not supported and cannot be trasferred as shareable, so we
+    // implement a simple detection mechanism that remembers the value at a given depth and
+    // tests whether we try reenter this method later on with the same value. If that happens
+    // we throw an appropriate error.
+    if (depth === DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD) {
+      processedObjectAtThresholdDepth = value;
+    } else if (value === processedObjectAtThresholdDepth) {
+      throw new Error('Trying to convert a cyclic object to a shareable. This is not supported.');
+    }
+  } else {
+    processedObjectAtThresholdDepth = undefined;
+  }
+  // This one actually may be worth to be moved to c++, we also need similar logic to run on the UI thread
   const type = typeof value;
-
-  if ((type === 'object' || type === 'function') && value !== null) {
+  const isTypeObject = type === 'object';
+  const isTypeFunction = type === 'function';
+  if ((isTypeObject || isTypeFunction) && value !== null) {
     const cached = _shareableCache.get(value);
-
     if (cached === _shareableFlag) {
       return value;
     } else if (cached !== undefined) {
       return cached;
     } else {
       let toAdapt;
-
       if (Array.isArray(value)) {
-        toAdapt = value.map(element => makeShareableCloneRecursive(element));
-      } else if (type === 'function' && value.__workletHash === undefined) {
+        toAdapt = value.map(element => makeShareableCloneRecursive(element, shouldPersistRemote, depth + 1));
+      } else if (isTypeFunction && value.__workletHash === undefined) {
         // this is a remote function
         toAdapt = value;
       } else if (isHostObject(value)) {
@@ -60,30 +110,46 @@ export function makeShareableCloneRecursive(value) {
         // then recreate new host object wrapping the same instance on the UI thread.
         // there is no point of iterating over keys as we do for regular objects.
         toAdapt = value;
-      } else {
+      } else if (isPlainJSObject(value) || isTypeFunction) {
         toAdapt = {};
-
         if (value.__workletHash !== undefined) {
           // we are converting a worklet
           if (__DEV__) {
+            if (
+            // We don't want this error to be logged more than once.
+            !didShowPluginVersionMismatchError && value.__version !== jsVersion) {
+              didShowPluginVersionMismatchError = true;
+              console.error(`[Reanimated] Mismatch between JavaScript code version and Reanimated Babel plugin version (${jsVersion} vs. ${value.__version}). Please clear your Metro bundler cache with \`yarn start --reset-cache\`,
+              \`npm start -- --reset-cache\` or \`expo start -c\` and run the app again.`);
+            }
             registerWorkletStackDetails(value.__workletHash, value.__stackDetails);
             delete value.__stackDetails;
-          } // to save on transferring static __initData field of worklet structure
+          }
+          // to save on transferring static __initData field of worklet structure
           // we request shareable value to persist its UI counterpart. This means
           // that the __initData field that contains long strings represeting the
           // worklet code, source map, and location, will always be
-          // serialized/deserialized once.
-
-
+          // serialized/deserialized once. We don't increase depth when calling
+          // this method as these objects have one level anyways.
           toAdapt.__initData = makeShareableCloneRecursive(value.__initData, true);
           delete value.__initData;
         }
-
         for (const [key, element] of Object.entries(value)) {
-          toAdapt[key] = makeShareableCloneRecursive(element);
+          toAdapt[key] = makeShareableCloneRecursive(element, shouldPersistRemote, depth + 1);
         }
+      } else {
+        // This is reached for object types that are not of plain Object.prototype.
+        // We don't support such objects from being transferred as shareables to
+        // the UI runtime and hence we replace them with "inaccessible object"
+        // which is implemented as a Proxy object that throws on any attempt
+        // of accessing its fields. We argue that such objects can sometimes leak
+        // as attributes of objects being captured by worklets but should never
+        // be used on the UI runtime regardless. If they are being accessed, the user
+        // will get an appropriate error message.
+        const inaccessibleObject = makeShareableCloneRecursive(INACCESSIBLE_OBJECT);
+        _shareableCache.set(value, inaccessibleObject);
+        return inaccessibleObject;
       }
-
       if (__DEV__) {
         // we freeze objects that are transformed to shareable. This should help
         // detect issues when someone modifies data after it's been converted to
@@ -93,17 +159,12 @@ export function makeShareableCloneRecursive(value) {
         // to be mutable they should use shared values instead.
         Object.freeze(value);
       }
-
       const adopted = NativeReanimatedModule.makeShareableClone(toAdapt, shouldPersistRemote);
-
       _shareableCache.set(value, adopted);
-
       _shareableCache.set(adopted, _shareableFlag);
-
       return adopted;
     }
   }
-
   return NativeReanimatedModule.makeShareableClone(value, shouldPersistRemote);
 }
 export function makeShareableCloneOnUIRecursive(value) {
@@ -114,41 +175,32 @@ export function makeShareableCloneOnUIRecursive(value) {
     // see more details in the comment where USE_STUB_IMPLEMENTATION is defined.
     return value;
   }
-
   function cloneRecursive(value) {
     const type = typeof value;
-
     if ((type === 'object' || type === 'function') && value !== null) {
       let toAdapt;
-
       if (Array.isArray(value)) {
         toAdapt = value.map(element => cloneRecursive(element));
-      } else {
+      } else if (value !== undefined) {
         toAdapt = {};
-
         for (const [key, element] of Object.entries(value)) {
           toAdapt[key] = cloneRecursive(element);
         }
       }
-
       if (__DEV__) {
         // See the reasoning behind freezing in the other comment above.
         Object.freeze(value);
       }
-
       return _makeShareableClone(toAdapt);
     }
-
     return _makeShareableClone(value);
   }
-
   return cloneRecursive(value);
 }
 export function makeShareable(value) {
   if (USE_STUB_IMPLEMENTATION) {
     return value;
   }
-
   const handle = makeShareableCloneRecursive({
     __init: () => {
       'worklet';

package/lib/module/reanimated2/shareables.js.map

@@ -1 +1 @@
-{"version":3,"names":["NativeReanimatedModule","shouldBeUseWeb","registerWorkletStackDetails","USE_STUB_IMPLEMENTATION","_shareableCache","WeakMap","_shareableFlag","Symbol","MAGIC_KEY","isHostObject","value","registerShareableMapping","shareable","shareableRef","set","makeShareableCloneRecursive","shouldPersistRemote","type","cached","get","undefined","toAdapt","Array","isArray","map","element","__workletHash","__DEV__","__stackDetails","__initData","key","Object","entries","freeze","adopted","makeShareableClone","makeShareableCloneOnUIRecursive","cloneRecursive","_makeShareableClone","makeShareable","handle","__init"],"sources":["shareables.ts"],"sourcesContent":["import NativeReanimatedModule from './NativeReanimated';\nimport { ShareableRef } from './commonTypes';\nimport { shouldBeUseWeb } from './PlatformChecker';\nimport { registerWorkletStackDetails } from './errors';\n\n// for web/chrome debugger/jest environments this file provides a stub implementation\n// where no shareable references are used. Instead, the objects themselves are used\n// instead of shareable references, because of the fact that we don't have to deal with\n// runnning the code on separate VMs.\nconst USE_STUB_IMPLEMENTATION = shouldBeUseWeb();\n\nconst _shareableCache = new WeakMap<\n  Record<string, unknown>,\n  ShareableRef<any> | symbol\n>();\n// the below symbol is used to represent a mapping from the value to itself\n// this is used to allow for a converted shareable to be passed to makeShareableClone\nconst _shareableFlag = Symbol('shareable flag');\n\nconst MAGIC_KEY = 'REANIMATED_MAGIC_KEY';\n\nfunction isHostObject(value: any): boolean {\n  // We could use JSI to determine whether an object is a host object, however\n  // the below workaround works well and is way faster than an additional JSI call.\n  // We use the fact that host objects have broken implementation of `hasOwnProperty`\n  // and hence return true for all `in` checks regardless of the key we ask for.\n  return MAGIC_KEY in value;\n}\n\nexport function registerShareableMapping(\n  shareable: any,\n  shareableRef?: ShareableRef<any>\n): void {\n  if (USE_STUB_IMPLEMENTATION) {\n    return;\n  }\n  _shareableCache.set(shareable, shareableRef || _shareableFlag);\n}\n\nexport function makeShareableCloneRecursive<T>(\n  value: any,\n  shouldPersistRemote = false\n): ShareableRef<T> {\n  if (USE_STUB_IMPLEMENTATION) {\n    return value;\n  }\n  // This one actually may be worth to be moved to c++, we also need similar logic to run on the UI thread\n  const type = typeof value;\n  if ((type === 'object' || type === 'function') && value !== null) {\n    const cached = _shareableCache.get(value);\n    if (cached === _shareableFlag) {\n      return value;\n    } else if (cached !== undefined) {\n      return cached as ShareableRef<T>;\n    } else {\n      let toAdapt: any;\n      if (Array.isArray(value)) {\n        toAdapt = value.map((element) => makeShareableCloneRecursive(element));\n      } else if (type === 'function' && value.__workletHash === undefined) {\n        // this is a remote function\n        toAdapt = value;\n      } else if (isHostObject(value)) {\n        // for host objects we pass the reference to the object as shareable and\n        // then recreate new host object wrapping the same instance on the UI thread.\n        // there is no point of iterating over keys as we do for regular objects.\n        toAdapt = value;\n      } else {\n        toAdapt = {};\n        if (value.__workletHash !== undefined) {\n          // we are converting a worklet\n          if (__DEV__) {\n            registerWorkletStackDetails(\n              value.__workletHash,\n              value.__stackDetails\n            );\n            delete value.__stackDetails;\n          }\n          // to save on transferring static __initData field of worklet structure\n          // we request shareable value to persist its UI counterpart. This means\n          // that the __initData field that contains long strings represeting the\n          // worklet code, source map, and location, will always be\n          // serialized/deserialized once.\n          toAdapt.__initData = makeShareableCloneRecursive(\n            value.__initData,\n            true\n          );\n          delete value.__initData;\n        }\n\n        for (const [key, element] of Object.entries(value)) {\n          toAdapt[key] = makeShareableCloneRecursive(element);\n        }\n      }\n      if (__DEV__) {\n        // we freeze objects that are transformed to shareable. This should help\n        // detect issues when someone modifies data after it's been converted to\n        // shareable. Meaning that they may be doing a faulty assumption in their\n        // code expecting that the updates are going to automatically populate to\n        // the object sent to the UI thread. If the user really wants some objects\n        // to be mutable they should use shared values instead.\n        Object.freeze(value);\n      }\n      const adopted = NativeReanimatedModule.makeShareableClone(\n        toAdapt,\n        shouldPersistRemote\n      );\n      _shareableCache.set(value, adopted);\n      _shareableCache.set(adopted, _shareableFlag);\n      return adopted;\n    }\n  }\n  return NativeReanimatedModule.makeShareableClone(value, shouldPersistRemote);\n}\n\nexport function makeShareableCloneOnUIRecursive<T>(value: T): ShareableRef<T> {\n  'worklet';\n  if (USE_STUB_IMPLEMENTATION) {\n    // @ts-ignore web is an interesting place where we don't run a secondary VM on the UI thread\n    // see more details in the comment where USE_STUB_IMPLEMENTATION is defined.\n    return value;\n  }\n  function cloneRecursive<T>(value: T): ShareableRef<T> {\n    const type = typeof value;\n    if ((type === 'object' || type === 'function') && value !== null) {\n      let toAdapt: any;\n      if (Array.isArray(value)) {\n        toAdapt = value.map((element) => cloneRecursive(element));\n      } else {\n        toAdapt = {};\n        for (const [key, element] of Object.entries(value)) {\n          toAdapt[key] = cloneRecursive(element);\n        }\n      }\n      if (__DEV__) {\n        // See the reasoning behind freezing in the other comment above.\n        Object.freeze(value);\n      }\n      return _makeShareableClone(toAdapt);\n    }\n    return _makeShareableClone(value);\n  }\n  return cloneRecursive(value);\n}\n\nexport function makeShareable<T>(value: T): T {\n  if (USE_STUB_IMPLEMENTATION) {\n    return value;\n  }\n  const handle = makeShareableCloneRecursive({\n    __init: () => {\n      'worklet';\n      return value;\n    },\n  });\n  registerShareableMapping(value, handle);\n  return value;\n}\n"],"mappings":"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"}
+{"version":3,"names":["NativeReanimatedModule","shouldBeUseWeb","registerWorkletStackDetails","jsVersion","USE_STUB_IMPLEMENTATION","_shareableCache","WeakMap","_shareableFlag","Symbol","MAGIC_KEY","isHostObject","value","registerShareableMapping","shareable","shareableRef","set","isPlainJSObject","object","Object","getPrototypeOf","prototype","INACCESSIBLE_OBJECT","__init","Proxy","get","_","prop","Error","DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD","processedObjectAtThresholdDepth","didShowPluginVersionMismatchError","makeShareableCloneRecursive","shouldPersistRemote","arguments","length","undefined","depth","type","isTypeObject","isTypeFunction","cached","toAdapt","Array","isArray","map","element","__workletHash","__DEV__","__version","console","error","__stackDetails","__initData","key","entries","inaccessibleObject","freeze","adopted","makeShareableClone","makeShareableCloneOnUIRecursive","cloneRecursive","_makeShareableClone","makeShareable","handle"],"sources":["shareables.ts"],"sourcesContent":["import NativeReanimatedModule from './NativeReanimated';\nimport { ShareableRef } from './commonTypes';\nimport { shouldBeUseWeb } from './PlatformChecker';\nimport { registerWorkletStackDetails } from './errors';\nimport { jsVersion } from './platform-specific/jsVersion';\n\n// for web/chrome debugger/jest environments this file provides a stub implementation\n// where no shareable references are used. Instead, the objects themselves are used\n// instead of shareable references, because of the fact that we don't have to deal with\n// runnning the code on separate VMs.\nconst USE_STUB_IMPLEMENTATION = shouldBeUseWeb();\n\nconst _shareableCache = new WeakMap<\n  Record<string, unknown>,\n  ShareableRef<any> | symbol\n>();\n// the below symbol is used to represent a mapping from the value to itself\n// this is used to allow for a converted shareable to be passed to makeShareableClone\nconst _shareableFlag = Symbol('shareable flag');\n\nconst MAGIC_KEY = 'REANIMATED_MAGIC_KEY';\n\nfunction isHostObject(value: any): boolean {\n  // We could use JSI to determine whether an object is a host object, however\n  // the below workaround works well and is way faster than an additional JSI call.\n  // We use the fact that host objects have broken implementation of `hasOwnProperty`\n  // and hence return true for all `in` checks regardless of the key we ask for.\n  return MAGIC_KEY in value;\n}\n\nexport function registerShareableMapping(\n  shareable: any,\n  shareableRef?: ShareableRef<any>\n): void {\n  if (USE_STUB_IMPLEMENTATION) {\n    return;\n  }\n  _shareableCache.set(shareable, shareableRef || _shareableFlag);\n}\n\nfunction isPlainJSObject(object: object) {\n  return Object.getPrototypeOf(object) === Object.prototype;\n}\n\n// The below object is used as a replacement for objects that cannot be transferred\n// as shareable values. In makeShareableCloneRecursive we detect if an object is of\n// a plain Object.prototype and only allow such objects to be transferred. This lets\n// us avoid all sorts of react internals from leaking into the UI runtime. To make it\n// possible to catch errors when someone actually tries to access such object on the UI\n// runtime, we use the below Proxy object which is instantiated on the UI runtime and\n// throws whenever someone tries to access its fields.\nconst INACCESSIBLE_OBJECT = {\n  __init: () => {\n    'worklet';\n    return new Proxy(\n      {},\n      {\n        get: (_: any, prop: string) => {\n          if (prop === '_isReanimatedSharedValue') {\n            // not very happy about this check here, but we need to allow for\n            // \"inaccessible\" objects to be tested with isSharedValue check\n            // as it is being used in the mappers when extracing inputs recursively.\n            // Apparently we can't check if a key exists there as HostObjects always\n            // return true for such tests, so the only possibility for us is to\n            // actually access that key and see if it is set to true. We therefore\n            // need to allow for this key to be accessed here.\n            return false;\n          }\n          throw new Error(\n            `Trying to access property \\`${prop}\\` of an object which cannot be sent to the UI runtime.`\n          );\n        },\n        set: () => {\n          throw new Error(\n            'Trying to write to an object which cannot be sent to the UI runtime.'\n          );\n        },\n      }\n    );\n  },\n};\n\nconst DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD = 30;\n// Below variable stores object that we process in makeShareableCloneRecursive at the specified depth.\n// We use it to check if later on the function reenters with the same object\nlet processedObjectAtThresholdDepth: any;\n\n// We only want to show mismatch error once so we use this flag to track it\nlet didShowPluginVersionMismatchError = false;\n\nexport function makeShareableCloneRecursive<T>(\n  value: any,\n  shouldPersistRemote = false,\n  depth = 0\n): ShareableRef<T> {\n  if (USE_STUB_IMPLEMENTATION) {\n    return value;\n  }\n  if (depth >= DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD) {\n    // if we reach certain recursion depth we suspect that we are dealing with a cyclic object.\n    // this type of objects are not supported and cannot be trasferred as shareable, so we\n    // implement a simple detection mechanism that remembers the value at a given depth and\n    // tests whether we try reenter this method later on with the same value. If that happens\n    // we throw an appropriate error.\n    if (depth === DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD) {\n      processedObjectAtThresholdDepth = value;\n    } else if (value === processedObjectAtThresholdDepth) {\n      throw new Error(\n        'Trying to convert a cyclic object to a shareable. This is not supported.'\n      );\n    }\n  } else {\n    processedObjectAtThresholdDepth = undefined;\n  }\n  // This one actually may be worth to be moved to c++, we also need similar logic to run on the UI thread\n  const type = typeof value;\n  const isTypeObject = type === 'object';\n  const isTypeFunction = type === 'function';\n  if ((isTypeObject || isTypeFunction) && value !== null) {\n    const cached = _shareableCache.get(value);\n    if (cached === _shareableFlag) {\n      return value;\n    } else if (cached !== undefined) {\n      return cached as ShareableRef<T>;\n    } else {\n      let toAdapt: any;\n      if (Array.isArray(value)) {\n        toAdapt = value.map((element) =>\n          makeShareableCloneRecursive(element, shouldPersistRemote, depth + 1)\n        );\n      } else if (isTypeFunction && value.__workletHash === undefined) {\n        // this is a remote function\n        toAdapt = value;\n      } else if (isHostObject(value)) {\n        // for host objects we pass the reference to the object as shareable and\n        // then recreate new host object wrapping the same instance on the UI thread.\n        // there is no point of iterating over keys as we do for regular objects.\n        toAdapt = value;\n      } else if (isPlainJSObject(value) || isTypeFunction) {\n        toAdapt = {};\n        if (value.__workletHash !== undefined) {\n          // we are converting a worklet\n          if (__DEV__) {\n            if (\n              // We don't want this error to be logged more than once.\n              !didShowPluginVersionMismatchError &&\n              value.__version !== jsVersion\n            ) {\n              didShowPluginVersionMismatchError = true;\n              console.error(`[Reanimated] Mismatch between JavaScript code version and Reanimated Babel plugin version (${jsVersion} vs. ${value.__version}). Please clear your Metro bundler cache with \\`yarn start --reset-cache\\`,\n              \\`npm start -- --reset-cache\\` or \\`expo start -c\\` and run the app again.`);\n            }\n            registerWorkletStackDetails(\n              value.__workletHash,\n              value.__stackDetails\n            );\n            delete value.__stackDetails;\n          }\n          // to save on transferring static __initData field of worklet structure\n          // we request shareable value to persist its UI counterpart. This means\n          // that the __initData field that contains long strings represeting the\n          // worklet code, source map, and location, will always be\n          // serialized/deserialized once. We don't increase depth when calling\n          // this method as these objects have one level anyways.\n          toAdapt.__initData = makeShareableCloneRecursive(\n            value.__initData,\n            true\n          );\n          delete value.__initData;\n        }\n\n        for (const [key, element] of Object.entries(value)) {\n          toAdapt[key] = makeShareableCloneRecursive(\n            element,\n            shouldPersistRemote,\n            depth + 1\n          );\n        }\n      } else {\n        // This is reached for object types that are not of plain Object.prototype.\n        // We don't support such objects from being transferred as shareables to\n        // the UI runtime and hence we replace them with \"inaccessible object\"\n        // which is implemented as a Proxy object that throws on any attempt\n        // of accessing its fields. We argue that such objects can sometimes leak\n        // as attributes of objects being captured by worklets but should never\n        // be used on the UI runtime regardless. If they are being accessed, the user\n        // will get an appropriate error message.\n        const inaccessibleObject =\n          makeShareableCloneRecursive<T>(INACCESSIBLE_OBJECT);\n        _shareableCache.set(value, inaccessibleObject);\n        return inaccessibleObject;\n      }\n      if (__DEV__) {\n        // we freeze objects that are transformed to shareable. This should help\n        // detect issues when someone modifies data after it's been converted to\n        // shareable. Meaning that they may be doing a faulty assumption in their\n        // code expecting that the updates are going to automatically populate to\n        // the object sent to the UI thread. If the user really wants some objects\n        // to be mutable they should use shared values instead.\n        Object.freeze(value);\n      }\n      const adopted = NativeReanimatedModule.makeShareableClone(\n        toAdapt,\n        shouldPersistRemote\n      );\n      _shareableCache.set(value, adopted);\n      _shareableCache.set(adopted, _shareableFlag);\n      return adopted;\n    }\n  }\n  return NativeReanimatedModule.makeShareableClone(value, shouldPersistRemote);\n}\n\nexport function makeShareableCloneOnUIRecursive<T>(value: T): ShareableRef<T> {\n  'worklet';\n  if (USE_STUB_IMPLEMENTATION) {\n    // @ts-ignore web is an interesting place where we don't run a secondary VM on the UI thread\n    // see more details in the comment where USE_STUB_IMPLEMENTATION is defined.\n    return value;\n  }\n  function cloneRecursive<T>(value: T): ShareableRef<T> {\n    const type = typeof value;\n    if ((type === 'object' || type === 'function') && value !== null) {\n      let toAdapt: any;\n      if (Array.isArray(value)) {\n        toAdapt = value.map((element) => cloneRecursive(element));\n      } else if (value !== undefined) {\n        toAdapt = {};\n        for (const [key, element] of Object.entries(value)) {\n          toAdapt[key] = cloneRecursive(element);\n        }\n      }\n      if (__DEV__) {\n        // See the reasoning behind freezing in the other comment above.\n        Object.freeze(value);\n      }\n      return _makeShareableClone(toAdapt);\n    }\n    return _makeShareableClone(value);\n  }\n  return cloneRecursive(value);\n}\n\nexport function makeShareable<T>(value: T): T {\n  if (USE_STUB_IMPLEMENTATION) {\n    return value;\n  }\n  const handle = makeShareableCloneRecursive({\n    __init: () => {\n      'worklet';\n      return value;\n    },\n  });\n  registerShareableMapping(value, handle);\n  return value;\n}\n"],"mappings":"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"}

package/lib/module/reanimated2/threads.js

@@ -4,52 +4,58 @@ import { makeShareableCloneOnUIRecursive, makeShareableCloneRecursive } from './
 const IS_JEST = isJest();
 const IS_WEB = shouldBeUseWeb();
 let _runOnUIQueue = [];
-export function setupSetImmediate() {
+export function setupMicrotasks() {
   'worklet';
 
-  let immediateCallbacks = []; // @ts-ignore – typescript expects this to conform to NodeJS definition and expects the return value to be NodeJS.Immediate which is an object and not a number
+  let microtasksQueue = [];
+  let isExecutingMicrotasksQueue = false;
 
-  global.setImmediate = callback => {
-    immediateCallbacks.push(callback);
+  // @ts-ignore – typescript expects this to conform to NodeJS definition and expects the return value to be NodeJS.Immediate which is an object and not a number
+  global.queueMicrotask = callback => {
+    microtasksQueue.push(callback);
     return -1;
   };
-
-  global.__flushImmediates = () => {
-    for (let index = 0; index < immediateCallbacks.length; index += 1) {
-      // we use classic 'for' loop because the size of the currentTasks array may change while executing some of the callbacks due to setImmediate calls
-      immediateCallbacks[index]();
+  global.__callMicrotasks = () => {
+    if (isExecutingMicrotasksQueue) {
+      return;
+    }
+    try {
+      isExecutingMicrotasksQueue = true;
+      for (let index = 0; index < microtasksQueue.length; index += 1) {
+        // we use classic 'for' loop because the size of the currentTasks array may change while executing some of the callbacks due to queueMicrotask calls
+        microtasksQueue[index]();
+      }
+      microtasksQueue = [];
+      global._maybeFlushUIUpdatesQueue();
+    } finally {
+      isExecutingMicrotasksQueue = false;
     }
-
-    immediateCallbacks = [];
   };
 }
-
-function flushImmediatesOnUIThread() {
+function callMicrotasksOnUIThread() {
   'worklet';
 
-  global.__flushImmediates();
+  global.__callMicrotasks();
 }
+export const callMicrotasks = shouldBeUseWeb() ? () => {
+  // on web flushing is a noop as immediates are handled by the browser
+} : callMicrotasksOnUIThread;
 
-export const flushImmediates = shouldBeUseWeb() ? () => {// on web flushing is a noop as immediates are handled by the browser
-} : flushImmediatesOnUIThread;
 /**
  * Schedule a worklet to execute on the UI runtime. This method does not schedule the work immediately but instead
- * waits for other worklets to be scheduled within the same JS loop. It uses setImmediate to schedule all the worklets
+ * waits for other worklets to be scheduled within the same JS loop. It uses queueMicrotask to schedule all the worklets
  * at once making sure they will run within the same frame boundaries on the UI thread.
  */
-
 export function runOnUI(worklet) {
   if (__DEV__ && !IS_WEB && worklet.__workletHash === undefined) {
     throw new Error('runOnUI() can only be used on worklets');
   }
-
   return function () {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
     if (IS_JEST) {
-      // Mocking time in Jest is tricky as both requestAnimationFrame and setImmediate
+      // Mocking time in Jest is tricky as both requestAnimationFrame and queueMicrotask
       // callbacks run on the same queue and can be interleaved. There is no way
       // to flush particular queue in Jest and the only control over mocked timers
       // is by using jest.advanceTimersByTime() method which advances all types
@@ -65,11 +71,18 @@ export function runOnUI(worklet) {
       }));
       return;
     }
-
+    if (__DEV__) {
+      // in DEV mode we call shareable conversion here because in case the object
+      // can't be converted, we will get a meaningful stack-trace as opposed to the
+      // situation when conversion is only done via microtask queue. This does not
+      // make the app particularily less efficient as converted objects are cached
+      // and for a given worklet the conversion only happens once.
+      makeShareableCloneRecursive(worklet);
+      makeShareableCloneRecursive(args);
+    }
     _runOnUIQueue.push([worklet, args]);
-
     if (_runOnUIQueue.length === 1) {
-      setImmediate(() => {
+      queueMicrotask(() => {
         const queue = _runOnUIQueue;
         _runOnUIQueue = [];
         NativeReanimatedModule.scheduleOnUI(makeShareableCloneRecursive(() => {
@@ -79,26 +92,24 @@ export function runOnUI(worklet) {
             let [worklet, args] = _ref;
             worklet(...args);
           });
-          flushImmediates();
+          callMicrotasks();
         }));
       });
     }
   };
 }
+
 /**
  * Schedule a worklet to execute on the UI runtime skipping batching mechanism.
  */
-
 export function runOnUIImmediately(worklet) {
   if (__DEV__ && !IS_WEB && worklet.__workletHash === undefined) {
     throw new Error('runOnUI() can only be used on worklets');
   }
-
   return function () {
     for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
       args[_key2] = arguments[_key2];
     }
-
     NativeReanimatedModule.scheduleOnUI(makeShareableCloneRecursive(() => {
       'worklet';
 
@@ -106,7 +117,6 @@ export function runOnUIImmediately(worklet) {
     }));
   };
 }
-
 if (__DEV__) {
   try {
     runOnUI(() => {
@@ -116,7 +126,6 @@ if (__DEV__) {
     throw new Error('Failed to create a worklet. Did you forget to add Reanimated Babel plugin in babel.config.js? See installation docs at https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation#babel-plugin.');
   }
 }
-
 export function runOnJS(fun) {
   'worklet';
 
@@ -127,16 +136,13 @@ export function runOnJS(fun) {
     // reference to the original remote function in the `__remoteFunction` property.
     fun = fun.__remoteFunction;
   }
-
   if (!_WORKLET) {
     return fun;
   }
-
   return function () {
     for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
       args[_key3] = arguments[_key3];
     }
-
     _scheduleOnJS(fun, args.length > 0 ? makeShareableCloneOnUIRecursive(args) : undefined);
   };
 }

package/lib/module/reanimated2/threads.js.map

@@ -1 +1 @@
-{"version":3,"names":["NativeReanimatedModule","isJest","shouldBeUseWeb","makeShareableCloneOnUIRecursive","makeShareableCloneRecursive","IS_JEST","IS_WEB","_runOnUIQueue","setupSetImmediate","immediateCallbacks","global","setImmediate","callback","push","__flushImmediates","index","length","flushImmediatesOnUIThread","flushImmediates","runOnUI","worklet","__DEV__","__workletHash","undefined","Error","args","scheduleOnUI","queue","forEach","runOnUIImmediately","e","runOnJS","fun","__remoteFunction","_WORKLET","_scheduleOnJS"],"sources":["threads.ts"],"sourcesContent":["import NativeReanimatedModule from './NativeReanimated';\nimport { isJest, shouldBeUseWeb } from './PlatformChecker';\nimport { ComplexWorkletFunction } from './commonTypes';\nimport {\n  makeShareableCloneOnUIRecursive,\n  makeShareableCloneRecursive,\n} from './shareables';\n\nconst IS_JEST = isJest();\nconst IS_WEB = shouldBeUseWeb();\n\nlet _runOnUIQueue: Array<[ComplexWorkletFunction<any[], any>, any[]]> = [];\n\nexport function setupSetImmediate() {\n  'worklet';\n\n  let immediateCallbacks: Array<() => void> = [];\n\n  // @ts-ignore – typescript expects this to conform to NodeJS definition and expects the return value to be NodeJS.Immediate which is an object and not a number\n  global.setImmediate = (callback: () => void): number => {\n    immediateCallbacks.push(callback);\n    return -1;\n  };\n\n  global.__flushImmediates = () => {\n    for (let index = 0; index < immediateCallbacks.length; index += 1) {\n      // we use classic 'for' loop because the size of the currentTasks array may change while executing some of the callbacks due to setImmediate calls\n      immediateCallbacks[index]();\n    }\n    immediateCallbacks = [];\n  };\n}\n\nfunction flushImmediatesOnUIThread() {\n  'worklet';\n  global.__flushImmediates();\n}\n\nexport const flushImmediates = shouldBeUseWeb()\n  ? () => {\n      // on web flushing is a noop as immediates are handled by the browser\n    }\n  : flushImmediatesOnUIThread;\n\n/**\n * Schedule a worklet to execute on the UI runtime. This method does not schedule the work immediately but instead\n * waits for other worklets to be scheduled within the same JS loop. It uses setImmediate to schedule all the worklets\n * at once making sure they will run within the same frame boundaries on the UI thread.\n */\nexport function runOnUI<A extends any[], R>(\n  worklet: ComplexWorkletFunction<A, R>\n): (...args: A) => void {\n  if (__DEV__ && !IS_WEB && worklet.__workletHash === undefined) {\n    throw new Error('runOnUI() can only be used on worklets');\n  }\n  return (...args) => {\n    if (IS_JEST) {\n      // Mocking time in Jest is tricky as both requestAnimationFrame and setImmediate\n      // callbacks run on the same queue and can be interleaved. There is no way\n      // to flush particular queue in Jest and the only control over mocked timers\n      // is by using jest.advanceTimersByTime() method which advances all types\n      // of timers including immediate and animation callbacks. Ideally we'd like\n      // to have some way here to schedule work along with React updates, but\n      // that's not possible, and hence in Jest environment instead of using scheduling\n      // mechanism we just schedule the work ommiting the queue. This is ok for the\n      // uses that we currently have but may not be ok for future tests that we write.\n      NativeReanimatedModule.scheduleOnUI(\n        makeShareableCloneRecursive(() => {\n          'worklet';\n          worklet(...args);\n        })\n      );\n      return;\n    }\n    _runOnUIQueue.push([worklet, args]);\n    if (_runOnUIQueue.length === 1) {\n      setImmediate(() => {\n        const queue = _runOnUIQueue;\n        _runOnUIQueue = [];\n        NativeReanimatedModule.scheduleOnUI(\n          makeShareableCloneRecursive(() => {\n            'worklet';\n            queue.forEach(([worklet, args]) => {\n              worklet(...args);\n            });\n            flushImmediates();\n          })\n        );\n      });\n    }\n  };\n}\n\n/**\n * Schedule a worklet to execute on the UI runtime skipping batching mechanism.\n */\nexport function runOnUIImmediately<A extends any[], R>(\n  worklet: ComplexWorkletFunction<A, R>\n): (...args: A) => void {\n  if (__DEV__ && !IS_WEB && worklet.__workletHash === undefined) {\n    throw new Error('runOnUI() can only be used on worklets');\n  }\n  return (...args) => {\n    NativeReanimatedModule.scheduleOnUI(\n      makeShareableCloneRecursive(() => {\n        'worklet';\n        worklet(...args);\n      })\n    );\n  };\n}\n\nif (__DEV__) {\n  try {\n    runOnUI(() => {\n      'worklet';\n    });\n  } catch (e) {\n    throw new Error(\n      'Failed to create a worklet. Did you forget to add Reanimated Babel plugin in babel.config.js? See installation docs at https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation#babel-plugin.'\n    );\n  }\n}\n\nexport function runOnJS<A extends any[], R>(\n  fun: ComplexWorkletFunction<A, R>\n): (...args: A) => void {\n  'worklet';\n  if (fun.__remoteFunction) {\n    // in development mode the function provided as `fun` throws an error message\n    // such that when someone accidently calls it directly on the UI runtime, they\n    // see that they should use `runOnJS` instead. To facilitate that we purt the\n    // reference to the original remote function in the `__remoteFunction` property.\n    fun = fun.__remoteFunction;\n  }\n  if (!_WORKLET) {\n    return fun;\n  }\n  return (...args) => {\n    _scheduleOnJS(\n      fun,\n      args.length > 0 ? makeShareableCloneOnUIRecursive(args) : undefined\n    );\n  };\n}\n"],"mappings":"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"}
+{"version":3,"names":["NativeReanimatedModule","isJest","shouldBeUseWeb","makeShareableCloneOnUIRecursive","makeShareableCloneRecursive","IS_JEST","IS_WEB","_runOnUIQueue","setupMicrotasks","microtasksQueue","isExecutingMicrotasksQueue","global","queueMicrotask","callback","push","__callMicrotasks","index","length","_maybeFlushUIUpdatesQueue","callMicrotasksOnUIThread","callMicrotasks","runOnUI","worklet","__DEV__","__workletHash","undefined","Error","_len","arguments","args","Array","_key","scheduleOnUI","queue","forEach","_ref","runOnUIImmediately","_len2","_key2","e","runOnJS","fun","__remoteFunction","_WORKLET","_len3","_key3","_scheduleOnJS"],"sources":["threads.ts"],"sourcesContent":["import NativeReanimatedModule from './NativeReanimated';\nimport { isJest, shouldBeUseWeb } from './PlatformChecker';\nimport { ComplexWorkletFunction } from './commonTypes';\nimport {\n  makeShareableCloneOnUIRecursive,\n  makeShareableCloneRecursive,\n} from './shareables';\n\nconst IS_JEST = isJest();\nconst IS_WEB = shouldBeUseWeb();\n\nlet _runOnUIQueue: Array<[ComplexWorkletFunction<any[], any>, any[]]> = [];\n\nexport function setupMicrotasks() {\n  'worklet';\n\n  let microtasksQueue: Array<() => void> = [];\n  let isExecutingMicrotasksQueue = false;\n\n  // @ts-ignore – typescript expects this to conform to NodeJS definition and expects the return value to be NodeJS.Immediate which is an object and not a number\n  global.queueMicrotask = (callback: () => void): number => {\n    microtasksQueue.push(callback);\n    return -1;\n  };\n\n  global.__callMicrotasks = () => {\n    if (isExecutingMicrotasksQueue) {\n      return;\n    }\n    try {\n      isExecutingMicrotasksQueue = true;\n      for (let index = 0; index < microtasksQueue.length; index += 1) {\n        // we use classic 'for' loop because the size of the currentTasks array may change while executing some of the callbacks due to queueMicrotask calls\n        microtasksQueue[index]();\n      }\n      microtasksQueue = [];\n      global._maybeFlushUIUpdatesQueue();\n    } finally {\n      isExecutingMicrotasksQueue = false;\n    }\n  };\n}\n\nfunction callMicrotasksOnUIThread() {\n  'worklet';\n  global.__callMicrotasks();\n}\n\nexport const callMicrotasks = shouldBeUseWeb()\n  ? () => {\n      // on web flushing is a noop as immediates are handled by the browser\n    }\n  : callMicrotasksOnUIThread;\n\n/**\n * Schedule a worklet to execute on the UI runtime. This method does not schedule the work immediately but instead\n * waits for other worklets to be scheduled within the same JS loop. It uses queueMicrotask to schedule all the worklets\n * at once making sure they will run within the same frame boundaries on the UI thread.\n */\nexport function runOnUI<A extends any[], R>(\n  worklet: ComplexWorkletFunction<A, R>\n): (...args: A) => void {\n  if (__DEV__ && !IS_WEB && worklet.__workletHash === undefined) {\n    throw new Error('runOnUI() can only be used on worklets');\n  }\n  return (...args) => {\n    if (IS_JEST) {\n      // Mocking time in Jest is tricky as both requestAnimationFrame and queueMicrotask\n      // callbacks run on the same queue and can be interleaved. There is no way\n      // to flush particular queue in Jest and the only control over mocked timers\n      // is by using jest.advanceTimersByTime() method which advances all types\n      // of timers including immediate and animation callbacks. Ideally we'd like\n      // to have some way here to schedule work along with React updates, but\n      // that's not possible, and hence in Jest environment instead of using scheduling\n      // mechanism we just schedule the work ommiting the queue. This is ok for the\n      // uses that we currently have but may not be ok for future tests that we write.\n      NativeReanimatedModule.scheduleOnUI(\n        makeShareableCloneRecursive(() => {\n          'worklet';\n          worklet(...args);\n        })\n      );\n      return;\n    }\n    if (__DEV__) {\n      // in DEV mode we call shareable conversion here because in case the object\n      // can't be converted, we will get a meaningful stack-trace as opposed to the\n      // situation when conversion is only done via microtask queue. This does not\n      // make the app particularily less efficient as converted objects are cached\n      // and for a given worklet the conversion only happens once.\n      makeShareableCloneRecursive(worklet);\n      makeShareableCloneRecursive(args);\n    }\n    _runOnUIQueue.push([worklet, args]);\n    if (_runOnUIQueue.length === 1) {\n      queueMicrotask(() => {\n        const queue = _runOnUIQueue;\n        _runOnUIQueue = [];\n        NativeReanimatedModule.scheduleOnUI(\n          makeShareableCloneRecursive(() => {\n            'worklet';\n            queue.forEach(([worklet, args]) => {\n              worklet(...args);\n            });\n            callMicrotasks();\n          })\n        );\n      });\n    }\n  };\n}\n\n/**\n * Schedule a worklet to execute on the UI runtime skipping batching mechanism.\n */\nexport function runOnUIImmediately<A extends any[], R>(\n  worklet: ComplexWorkletFunction<A, R>\n): (...args: A) => void {\n  if (__DEV__ && !IS_WEB && worklet.__workletHash === undefined) {\n    throw new Error('runOnUI() can only be used on worklets');\n  }\n  return (...args) => {\n    NativeReanimatedModule.scheduleOnUI(\n      makeShareableCloneRecursive(() => {\n        'worklet';\n        worklet(...args);\n      })\n    );\n  };\n}\n\nif (__DEV__) {\n  try {\n    runOnUI(() => {\n      'worklet';\n    });\n  } catch (e) {\n    throw new Error(\n      'Failed to create a worklet. Did you forget to add Reanimated Babel plugin in babel.config.js? See installation docs at https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation#babel-plugin.'\n    );\n  }\n}\n\nexport function runOnJS<A extends any[], R>(\n  fun: ComplexWorkletFunction<A, R>\n): (...args: A) => void {\n  'worklet';\n  if (fun.__remoteFunction) {\n    // in development mode the function provided as `fun` throws an error message\n    // such that when someone accidently calls it directly on the UI runtime, they\n    // see that they should use `runOnJS` instead. To facilitate that we purt the\n    // reference to the original remote function in the `__remoteFunction` property.\n    fun = fun.__remoteFunction;\n  }\n  if (!_WORKLET) {\n    return fun;\n  }\n  return (...args) => {\n    _scheduleOnJS(\n      fun,\n      args.length > 0 ? makeShareableCloneOnUIRecursive(args) : undefined\n    );\n  };\n}\n"],"mappings":"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"}

package/lib/module/reanimated2/utils.js

@@ -1,5 +1,4 @@
 import { measure } from './NativeMethods';
-
 /**
  * Given an absolute position and a component ref, returns the relative
  * position in the component's local coordinate space.
@@ -8,11 +7,9 @@ export function getRelativeCoords(parentRef, absoluteX, absoluteY) {
   'worklet';
 
   const parentCoords = measure(parentRef);
-
   if (parentCoords === null) {
     return null;
   }
-
   return {
     x: absoluteX - parentCoords.x,
     y: absoluteY - parentCoords.y

package/lib/module/reanimated2/utils.js.map

@@ -1 +1 @@
-{"version":3,"names":["measure","getRelativeCoords","parentRef","absoluteX","absoluteY","parentCoords","x","y","isSharedValue","value","_isReanimatedSharedValue"],"sources":["utils.ts"],"sourcesContent":["import { Component } from 'react';\nimport { measure } from './NativeMethods';\nimport { RefObjectFunction } from './hook/commonTypes';\nimport { SharedValue } from './commonTypes';\n\nexport interface ComponentCoords {\n  x: number;\n  y: number;\n}\n\n/**\n * Given an absolute position and a component ref, returns the relative\n * position in the component's local coordinate space.\n */\nexport function getRelativeCoords(\n  parentRef: RefObjectFunction<Component>,\n  absoluteX: number,\n  absoluteY: number\n): ComponentCoords | null {\n  'worklet';\n  const parentCoords = measure(parentRef);\n  if (parentCoords === null) {\n    return null;\n  }\n  return {\n    x: absoluteX - parentCoords.x,\n    y: absoluteY - parentCoords.y,\n  };\n}\n\nexport function isSharedValue<T>(value: any): value is SharedValue<T> {\n  'worklet';\n  return value?._isReanimatedSharedValue === true;\n}\n"],"mappings":"AACA,SAASA,OAAT,QAAwB,iBAAxB;;AASA;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAT,CACLC,SADK,EAELC,SAFK,EAGLC,SAHK,EAImB;EACxB;;EACA,MAAMC,YAAY,GAAGL,OAAO,CAACE,SAAD,CAA5B;;EACA,IAAIG,YAAY,KAAK,IAArB,EAA2B;IACzB,OAAO,IAAP;EACD;;EACD,OAAO;IACLC,CAAC,EAAEH,SAAS,GAAGE,YAAY,CAACC,CADvB;IAELC,CAAC,EAAEH,SAAS,GAAGC,YAAY,CAACE;EAFvB,CAAP;AAID;AAED,OAAO,SAASC,aAAT,CAA0BC,KAA1B,EAA+D;EACpE;;EACA,OAAO,CAAAA,KAAK,SAAL,IAAAA,KAAK,WAAL,YAAAA,KAAK,CAAEC,wBAAP,MAAoC,IAA3C;AACD"}
+{"version":3,"names":["measure","getRelativeCoords","parentRef","absoluteX","absoluteY","parentCoords","x","y","isSharedValue","value","_isReanimatedSharedValue"],"sources":["utils.ts"],"sourcesContent":["import { Component } from 'react';\nimport { measure } from './NativeMethods';\nimport { RefObjectFunction } from './hook/commonTypes';\nimport { SharedValue } from './commonTypes';\n\nexport interface ComponentCoords {\n  x: number;\n  y: number;\n}\n\n/**\n * Given an absolute position and a component ref, returns the relative\n * position in the component's local coordinate space.\n */\nexport function getRelativeCoords(\n  parentRef: RefObjectFunction<Component>,\n  absoluteX: number,\n  absoluteY: number\n): ComponentCoords | null {\n  'worklet';\n  const parentCoords = measure(parentRef);\n  if (parentCoords === null) {\n    return null;\n  }\n  return {\n    x: absoluteX - parentCoords.x,\n    y: absoluteY - parentCoords.y,\n  };\n}\n\nexport function isSharedValue<T>(value: any): value is SharedValue<T> {\n  'worklet';\n  return value?._isReanimatedSharedValue === true;\n}\n"],"mappings":"AACA,SAASA,OAAO,QAAQ,iBAAiB;AASzC;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAC/BC,SAAuC,EACvCC,SAAiB,EACjBC,SAAiB,EACO;EACxB,SAAS;;EACT,MAAMC,YAAY,GAAGL,OAAO,CAACE,SAAS,CAAC;EACvC,IAAIG,YAAY,KAAK,IAAI,EAAE;IACzB,OAAO,IAAI;EACb;EACA,OAAO;IACLC,CAAC,EAAEH,SAAS,GAAGE,YAAY,CAACC,CAAC;IAC7BC,CAAC,EAAEH,SAAS,GAAGC,YAAY,CAACE;EAC9B,CAAC;AACH;AAEA,OAAO,SAASC,aAAaA,CAAIC,KAAU,EAA2B;EACpE,SAAS;;EACT,OAAO,CAAAA,KAAK,aAALA,KAAK,uBAALA,KAAK,CAAEC,wBAAwB,MAAK,IAAI;AACjD"}

package/lib/module/reanimated2/valueSetter.js

@@ -3,53 +3,41 @@ export function valueSetter(sv, value) {
   'worklet';
 
   const previousAnimation = sv._animation;
-
   if (previousAnimation) {
     previousAnimation.cancelled = true;
     sv._animation = null;
   }
-
   if (typeof value === 'function' || value !== null && typeof value === 'object' && value.onFrame !== undefined) {
-    const animation = typeof value === 'function' ? value() : value; // prevent setting again to the same value
+    const animation = typeof value === 'function' ? value() : value;
+    // prevent setting again to the same value
     // and triggering the mappers that treat this value as an input
     // this happens when the animation's target value(stored in animation.current until animation.onStart is called) is set to the same value as a current one(this._value)
     // built in animations that are not higher order(withTiming, withSpring) hold target value in .current
-
     if (sv._value === animation.current && !animation.isHigherOrder) {
       animation.callback && animation.callback(true);
       return;
-    } // animated set
-
-
+    }
+    // animated set
     const initializeAnimation = timestamp => {
       animation.onStart(animation, sv.value, timestamp, previousAnimation);
     };
-
     const currentTimestamp = global.__frameTimestamp || performance.now();
     initializeAnimation(currentTimestamp);
-
     const step = timestamp => {
       if (animation.cancelled) {
-        animation.callback && animation.callback(false
-        /* finished */
-        );
+        animation.callback && animation.callback(false /* finished */);
         return;
       }
-
       const finished = animation.onFrame(animation, timestamp);
       animation.finished = true;
       animation.timestamp = timestamp;
       sv._value = animation.current;
-
       if (finished) {
-        animation.callback && animation.callback(true
-        /* finished */
-        );
+        animation.callback && animation.callback(true /* finished */);
       } else {
         requestAnimationFrame(step);
       }
     };
-
     sv._animation = animation;
     step(currentTimestamp);
   } else {
@@ -58,7 +46,6 @@ export function valueSetter(sv, value) {
     if (sv._value === value) {
       return;
     }
-
     sv._value = value;
   }
 }