react-native-reanimated 3.0.2 → 3.1.0

package/src/reanimated2/mappers.ts

@@ -1,6 +1,7 @@
 import { SharedValue } from './commonTypes';
 import { isJest } from './PlatformChecker';
 import { runOnUI } from './threads';
+import { isSharedValue } from './utils';
 
 const IS_JEST = isJest();
 
@@ -18,6 +19,7 @@ export function createMapperRegistry() {
   let sortedMappers: Mapper[] = [];
 
   let runRequested = false;
+  let processingMappers = false;
 
   function updateMappersOrder() {
     // sort mappers topologically
@@ -78,6 +80,7 @@ export function createMapperRegistry() {
   }
 
   function mapperRun() {
+    processingMappers = true;
     runRequested = false;
     if (mappers.size !== sortedMappers.length) {
       updateMappersOrder();
@@ -88,11 +91,12 @@ export function createMapperRegistry() {
         mapper.worklet();
       }
     }
+    processingMappers = false;
   }
 
   function maybeRequestUpdates() {
     if (IS_JEST) {
-      // On Jest environment we avoid using setImmediate as that'd require test
+      // On Jest environment we avoid using queueMicrotask as that'd require test
       // to advance the clock manually. This on other hand would require tests
       // to know how many times mappers need to run. As we don't want tests to
       // make any assumptions on that number it is easier to execute mappers
@@ -100,7 +104,22 @@ export function createMapperRegistry() {
       // if they want to make any assertions on the effects of animations being run.
       mapperRun();
     } else if (!runRequested) {
-      setImmediate(mapperRun);
+      if (processingMappers) {
+        // In general, we should avoid having mappers trigger updates as this may
+        // result in unpredictable behavior. Specifically, the updated value can
+        // be read by mappers that run later in the same frame but previous mappers
+        // would access the old value. Updating mappers during the mapper-run phase
+        // breaks the order in which we should execute the mappers. However, doing
+        // that is still a possibility and there are some instances where people use
+        // the API in that way, hence we need to prevent mapper-run phase falling into
+        // an infinite loop. We do that by detecting when mapper-run is requested while
+        // we are already in mapper-run phase, and in that case we use `requestAnimationFrame`
+        // instead of `queueMicrotask` which will schedule mapper run for the next
+        // frame instead of queuing another set of updates in the same frame.
+        requestAnimationFrame(mapperRun);
+      } else {
+        queueMicrotask(mapperRun);
+      }
       runRequested = true;
     }
   }
@@ -113,9 +132,12 @@ export function createMapperRegistry() {
       for (const input of inputs) {
         input && extractInputs(input, resultArray);
       }
-    } else if (inputs.addListener) {
+    } else if (isSharedValue(inputs)) {
       resultArray.push(inputs);
-    } else if (typeof inputs === 'object') {
+    } else if (Object.getPrototypeOf(inputs) === Object.prototype) {
+      // we only extract inputs recursively from "plain" objects here, if object
+      // is of a derivative class (e.g. HostObject on web, or Map) we don't scan
+      // it recursively
       for (const element of Object.values(inputs)) {
         element && extractInputs(element, resultArray);
       }

package/src/reanimated2/mock.ts

@@ -99,6 +99,7 @@ const ReanimatedV2 = {
     bounce: ID,
     bezier: () => ({ factory: ID }),
     bezierFn: ID,
+    steps: ID,
     in: ID,
     out: ID,
     inOut: ID,

package/src/reanimated2/platform-specific/checkCppVersion.ts

@@ -0,0 +1,29 @@
+import { jsVersion } from './jsVersion';
+
+export function checkCppVersion() {
+  const cppVersion = global._REANIMATED_VERSION_CPP;
+  if (cppVersion === undefined) {
+    console.error(
+      `[Reanimated] Couldn't determine the version of the native part of Reanimated. Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must use the exact version which is bundled into Expo SDK.`
+    );
+    return;
+  }
+  const ok = matchVersion(jsVersion, cppVersion);
+  if (!ok) {
+    console.error(
+      `[Reanimated] Mismatch between JavaScript part and native part of Reanimated (${jsVersion} vs. ${cppVersion}). Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must downgrade to ${cppVersion} which is bundled into Expo SDK.`
+    );
+  }
+}
+
+export function matchVersion(version1: string, version2: string) {
+  if (version1.match(/^\d+\.\d+\.\d+$/) && version2.match(/^\d+\.\d+\.\d+$/)) {
+    // x.y.z, compare only major and minor, skip patch
+    const [major1, minor1] = version1.split('.');
+    const [major2, minor2] = version2.split('.');
+    return major1 === major2 && minor1 === minor2;
+  } else {
+    // alpha, beta or rc, compare everything
+    return version1 === version2;
+  }
+}

package/src/reanimated2/platform-specific/jsVersion.ts

@@ -0,0 +1,6 @@
+/**
+ * We hardcode the version of Reanimated here in order to compare it
+ * with the version used to build the native part of the library in runtime.
+ * Remember to keep this in sync with the version declared in `package.json`
+ */
+export const jsVersion = '3.1.0';

package/src/reanimated2/shareables.ts

@@ -2,6 +2,7 @@ import NativeReanimatedModule from './NativeReanimated';
 import { ShareableRef } from './commonTypes';
 import { shouldBeUseWeb } from './PlatformChecker';
 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
@@ -37,16 +38,85 @@ export function registerShareableMapping(
   _shareableCache.set(shareable, shareableRef || _shareableFlag);
 }
 
+function isPlainJSObject(object: 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: (_: any, prop: string) => {
+          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: any;
+
+// We only want to show mismatch error once so we use this flag to track it
+let didShowPluginVersionMismatchError = false;
+
 export function makeShareableCloneRecursive<T>(
   value: any,
-  shouldPersistRemote = false
+  shouldPersistRemote = false,
+  depth = 0
 ): ShareableRef<T> {
   if (USE_STUB_IMPLEMENTATION) {
     return value;
   }
+  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;
@@ -55,8 +125,10 @@ export function makeShareableCloneRecursive<T>(
     } else {
       let toAdapt: any;
       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)) {
@@ -64,11 +136,20 @@ export function makeShareableCloneRecursive<T>(
         // 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
@@ -79,7 +160,8 @@ export function makeShareableCloneRecursive<T>(
           // 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
@@ -88,8 +170,25 @@ export function makeShareableCloneRecursive<T>(
         }
 
         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<T>(INACCESSIBLE_OBJECT);
+        _shareableCache.set(value, inaccessibleObject);
+        return inaccessibleObject;
       }
       if (__DEV__) {
         // we freeze objects that are transformed to shareable. This should help
@@ -125,7 +224,7 @@ export function makeShareableCloneOnUIRecursive<T>(value: T): ShareableRef<T> {
       let toAdapt: any;
       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);

package/src/reanimated2/threads.ts

@@ -11,40 +11,50 @@ const IS_WEB = shouldBeUseWeb();
 
 let _runOnUIQueue: Array<[ComplexWorkletFunction<any[], any>, any[]]> = [];
 
-export function setupSetImmediate() {
+export function setupMicrotasks() {
   'worklet';
 
-  let immediateCallbacks: Array<() => void> = [];
+  let microtasksQueue: Array<() => void> = [];
+  let isExecutingMicrotasksQueue = false;
 
   // @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.setImmediate = (callback: () => void): number => {
-    immediateCallbacks.push(callback);
+  global.queueMicrotask = (callback: () => void): number => {
+    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 flushImmediates = shouldBeUseWeb()
+export const callMicrotasks = shouldBeUseWeb()
   ? () => {
       // on web flushing is a noop as immediates are handled by the browser
     }
-  : flushImmediatesOnUIThread;
+  : callMicrotasksOnUIThread;
 
 /**
  * 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<A extends any[], R>(
@@ -55,7 +65,7 @@ export function runOnUI<A extends any[], R>(
   }
   return (...args) => {
     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
@@ -72,9 +82,18 @@ export function runOnUI<A extends any[], R>(
       );
       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(
@@ -83,7 +102,7 @@ export function runOnUI<A extends any[], R>(
             queue.forEach(([worklet, args]) => {
               worklet(...args);
             });
-            flushImmediates();
+            callMicrotasks();
           })
         );
       });

package/lib/commonjs/reanimated2/platform-specific/checkVersion.js

@@ -1,42 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.checkVersion = checkVersion;
-
-/**
- * We hardcode the version of Reanimated here in order to compare it
- * with the version used to build the native part of the library in runtime.
- * Remember to keep this in sync with the version declared in `package.json`
- */
-const jsVersion = '3.0.2';
-/**
- * Checks that native and js versions of reanimated match.
- */
-
-function checkVersion() {
-  const cppVersion = global._REANIMATED_VERSION_CPP;
-
-  if (cppVersion === undefined) {
-    console.error(`[Reanimated] Couldn't determine the version of the native part of Reanimated. Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must use the exact version which is bundled into Expo SDK.`);
-    return;
-  }
-
-  const ok = (() => {
-    if (jsVersion.match(/^\d+\.\d+\.\d+$/) && cppVersion.match(/^\d+\.\d+\.\d+$/)) {
-      // x.y.z, compare only major and minor, skip patch
-      const [jsMajor, jsMinor] = jsVersion.split('.');
-      const [cppMajor, cppMinor] = cppVersion.split('.');
-      return jsMajor === cppMajor && jsMinor === cppMinor;
-    } else {
-      // alpha, beta or rc, compare everything
-      return jsVersion === cppVersion;
-    }
-  })();
-
-  if (!ok) {
-    console.error(`[Reanimated] Mismatch between JavaScript part and native part of Reanimated (${jsVersion} vs. ${cppVersion}). Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must downgrade to ${cppVersion} which is bundled into Expo SDK.`); // TODO: detect Expo managed workflow
-  }
-}
-//# sourceMappingURL=checkVersion.js.map

package/lib/commonjs/reanimated2/platform-specific/checkVersion.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["jsVersion","checkVersion","cppVersion","global","_REANIMATED_VERSION_CPP","undefined","console","error","ok","match","jsMajor","jsMinor","split","cppMajor","cppMinor"],"sources":["checkVersion.ts"],"sourcesContent":["/**\n * We hardcode the version of Reanimated here in order to compare it\n * with the version used to build the native part of the library in runtime.\n * Remember to keep this in sync with the version declared in `package.json`\n */\nconst jsVersion = '3.0.2';\n\n/**\n * Checks that native and js versions of reanimated match.\n */\nexport function checkVersion(): void {\n  const cppVersion = global._REANIMATED_VERSION_CPP;\n  if (cppVersion === undefined) {\n    console.error(\n      `[Reanimated] Couldn't determine the version of the native part of Reanimated. Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must use the exact version which is bundled into Expo SDK.`\n    );\n    return;\n  }\n  const ok = (() => {\n    if (\n      jsVersion.match(/^\\d+\\.\\d+\\.\\d+$/) &&\n      cppVersion.match(/^\\d+\\.\\d+\\.\\d+$/)\n    ) {\n      // x.y.z, compare only major and minor, skip patch\n      const [jsMajor, jsMinor] = jsVersion.split('.');\n      const [cppMajor, cppMinor] = cppVersion.split('.');\n      return jsMajor === cppMajor && jsMinor === cppMinor;\n    } else {\n      // alpha, beta or rc, compare everything\n      return jsVersion === cppVersion;\n    }\n  })();\n  if (!ok) {\n    console.error(\n      `[Reanimated] Mismatch between JavaScript part and native part of Reanimated (${jsVersion} vs. ${cppVersion}). Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must downgrade to ${cppVersion} which is bundled into Expo SDK.`\n    );\n    // TODO: detect Expo managed workflow\n  }\n}\n"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA,MAAMA,SAAS,GAAG,OAAlB;AAEA;AACA;AACA;;AACO,SAASC,YAAT,GAA8B;EACnC,MAAMC,UAAU,GAAGC,MAAM,CAACC,uBAA1B;;EACA,IAAIF,UAAU,KAAKG,SAAnB,EAA8B;IAC5BC,OAAO,CAACC,KAAR,CACG,8OADH;IAGA;EACD;;EACD,MAAMC,EAAE,GAAG,CAAC,MAAM;IAChB,IACER,SAAS,CAACS,KAAV,CAAgB,iBAAhB,KACAP,UAAU,CAACO,KAAX,CAAiB,iBAAjB,CAFF,EAGE;MACA;MACA,MAAM,CAACC,OAAD,EAAUC,OAAV,IAAqBX,SAAS,CAACY,KAAV,CAAgB,GAAhB,CAA3B;MACA,MAAM,CAACC,QAAD,EAAWC,QAAX,IAAuBZ,UAAU,CAACU,KAAX,CAAiB,GAAjB,CAA7B;MACA,OAAOF,OAAO,KAAKG,QAAZ,IAAwBF,OAAO,KAAKG,QAA3C;IACD,CARD,MAQO;MACL;MACA,OAAOd,SAAS,KAAKE,UAArB;IACD;EACF,CAbU,GAAX;;EAcA,IAAI,CAACM,EAAL,EAAS;IACPF,OAAO,CAACC,KAAR,CACG,gFAA+EP,SAAU,QAAOE,UAAW,4HAA2HA,UAAW,kCADpP,EADO,CAIP;EACD;AACF"}

package/lib/module/reanimated2/platform-specific/checkVersion.js

@@ -1,35 +0,0 @@
-/**
- * We hardcode the version of Reanimated here in order to compare it
- * with the version used to build the native part of the library in runtime.
- * Remember to keep this in sync with the version declared in `package.json`
- */
-const jsVersion = '3.0.2';
-/**
- * Checks that native and js versions of reanimated match.
- */
-
-export function checkVersion() {
-  const cppVersion = global._REANIMATED_VERSION_CPP;
-
-  if (cppVersion === undefined) {
-    console.error(`[Reanimated] Couldn't determine the version of the native part of Reanimated. Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must use the exact version which is bundled into Expo SDK.`);
-    return;
-  }
-
-  const ok = (() => {
-    if (jsVersion.match(/^\d+\.\d+\.\d+$/) && cppVersion.match(/^\d+\.\d+\.\d+$/)) {
-      // x.y.z, compare only major and minor, skip patch
-      const [jsMajor, jsMinor] = jsVersion.split('.');
-      const [cppMajor, cppMinor] = cppVersion.split('.');
-      return jsMajor === cppMajor && jsMinor === cppMinor;
-    } else {
-      // alpha, beta or rc, compare everything
-      return jsVersion === cppVersion;
-    }
-  })();
-
-  if (!ok) {
-    console.error(`[Reanimated] Mismatch between JavaScript part and native part of Reanimated (${jsVersion} vs. ${cppVersion}). Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must downgrade to ${cppVersion} which is bundled into Expo SDK.`); // TODO: detect Expo managed workflow
-  }
-}
-//# sourceMappingURL=checkVersion.js.map

package/lib/module/reanimated2/platform-specific/checkVersion.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["jsVersion","checkVersion","cppVersion","global","_REANIMATED_VERSION_CPP","undefined","console","error","ok","match","jsMajor","jsMinor","split","cppMajor","cppMinor"],"sources":["checkVersion.ts"],"sourcesContent":["/**\n * We hardcode the version of Reanimated here in order to compare it\n * with the version used to build the native part of the library in runtime.\n * Remember to keep this in sync with the version declared in `package.json`\n */\nconst jsVersion = '3.0.2';\n\n/**\n * Checks that native and js versions of reanimated match.\n */\nexport function checkVersion(): void {\n  const cppVersion = global._REANIMATED_VERSION_CPP;\n  if (cppVersion === undefined) {\n    console.error(\n      `[Reanimated] Couldn't determine the version of the native part of Reanimated. Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must use the exact version which is bundled into Expo SDK.`\n    );\n    return;\n  }\n  const ok = (() => {\n    if (\n      jsVersion.match(/^\\d+\\.\\d+\\.\\d+$/) &&\n      cppVersion.match(/^\\d+\\.\\d+\\.\\d+$/)\n    ) {\n      // x.y.z, compare only major and minor, skip patch\n      const [jsMajor, jsMinor] = jsVersion.split('.');\n      const [cppMajor, cppMinor] = cppVersion.split('.');\n      return jsMajor === cppMajor && jsMinor === cppMinor;\n    } else {\n      // alpha, beta or rc, compare everything\n      return jsVersion === cppVersion;\n    }\n  })();\n  if (!ok) {\n    console.error(\n      `[Reanimated] Mismatch between JavaScript part and native part of Reanimated (${jsVersion} vs. ${cppVersion}). Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must downgrade to ${cppVersion} which is bundled into Expo SDK.`\n    );\n    // TODO: detect Expo managed workflow\n  }\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,MAAMA,SAAS,GAAG,OAAlB;AAEA;AACA;AACA;;AACA,OAAO,SAASC,YAAT,GAA8B;EACnC,MAAMC,UAAU,GAAGC,MAAM,CAACC,uBAA1B;;EACA,IAAIF,UAAU,KAAKG,SAAnB,EAA8B;IAC5BC,OAAO,CAACC,KAAR,CACG,8OADH;IAGA;EACD;;EACD,MAAMC,EAAE,GAAG,CAAC,MAAM;IAChB,IACER,SAAS,CAACS,KAAV,CAAgB,iBAAhB,KACAP,UAAU,CAACO,KAAX,CAAiB,iBAAjB,CAFF,EAGE;MACA;MACA,MAAM,CAACC,OAAD,EAAUC,OAAV,IAAqBX,SAAS,CAACY,KAAV,CAAgB,GAAhB,CAA3B;MACA,MAAM,CAACC,QAAD,EAAWC,QAAX,IAAuBZ,UAAU,CAACU,KAAX,CAAiB,GAAjB,CAA7B;MACA,OAAOF,OAAO,KAAKG,QAAZ,IAAwBF,OAAO,KAAKG,QAA3C;IACD,CARD,MAQO;MACL;MACA,OAAOd,SAAS,KAAKE,UAArB;IACD;EACF,CAbU,GAAX;;EAcA,IAAI,CAACM,EAAL,EAAS;IACPF,OAAO,CAACC,KAAR,CACG,gFAA+EP,SAAU,QAAOE,UAAW,4HAA2HA,UAAW,kCADpP,EADO,CAIP;EACD;AACF"}

package/src/reanimated2/platform-specific/checkVersion.ts

@@ -1,39 +0,0 @@
-/**
- * We hardcode the version of Reanimated here in order to compare it
- * with the version used to build the native part of the library in runtime.
- * Remember to keep this in sync with the version declared in `package.json`
- */
-const jsVersion = '3.0.2';
-
-/**
- * Checks that native and js versions of reanimated match.
- */
-export function checkVersion(): void {
-  const cppVersion = global._REANIMATED_VERSION_CPP;
-  if (cppVersion === undefined) {
-    console.error(
-      `[Reanimated] Couldn't determine the version of the native part of Reanimated. Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must use the exact version which is bundled into Expo SDK.`
-    );
-    return;
-  }
-  const ok = (() => {
-    if (
-      jsVersion.match(/^\d+\.\d+\.\d+$/) &&
-      cppVersion.match(/^\d+\.\d+\.\d+$/)
-    ) {
-      // x.y.z, compare only major and minor, skip patch
-      const [jsMajor, jsMinor] = jsVersion.split('.');
-      const [cppMajor, cppMinor] = cppVersion.split('.');
-      return jsMajor === cppMajor && jsMinor === cppMinor;
-    } else {
-      // alpha, beta or rc, compare everything
-      return jsVersion === cppVersion;
-    }
-  })();
-  if (!ok) {
-    console.error(
-      `[Reanimated] Mismatch between JavaScript part and native part of Reanimated (${jsVersion} vs. ${cppVersion}). Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must downgrade to ${cppVersion} which is bundled into Expo SDK.`
-    );
-    // TODO: detect Expo managed workflow
-  }
-}