feat(Worklets): use int64 for BigInt when possible (#8557)

## Summary

Small optimization that uses int64 type for BigInts whenever they fit in
that range.

## Test plan

- New runtime tests
- I checked in debugger that both paths execute properly.

Author: tjzel

apps/common-app/src/apps/reanimated/examples/RuntimeTests/tests/memory/createSerializable.test.tsx

@@ -1,3 +1,7 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import React, { useEffect } from 'react';
 import { View } from 'react-native';
 import { useSharedValue } from 'react-native-reanimated';
@@ -32,11 +36,11 @@ const ValueComponent = ({ onRunUIFunction }: { onRunUIFunction: () => boolean })
         try {
           const result = onRunUIFunction();
           sharedResult.value = result ? 'ok' : 'not_ok';
-        } catch (error) {
+        } catch {
           sharedResult.value = 'error';
         }
       });
-    } catch (error) {
+    } catch {
       sharedResult.value = 'error';
     }
     notify(DONE_NOTIFICATION_NAME);
@@ -178,7 +182,7 @@ describe('Test createSerializable', () => {
     expect(sharedValue.onJS).toBe('ok');
   });
 
-  test('createSerializableBigInt', async () => {
+  test('createSerializableBigInt fitting in int64', async () => {
     // Arrange
     const bigIntValue = BigInt(123);
 
@@ -200,9 +204,31 @@ describe('Test createSerializable', () => {
     expect(sharedValue.onJS).toBe('ok');
   });
 
+  test('createSerializableBigInt too big for uint64', async () => {
+    // Arrange
+    const maxInt64 = BigInt('0x7FFFFFFFFFFFFFFF');
+    const bigIntValue = maxInt64 * maxInt64;
+
+    // Act
+    await render(
+      <ValueComponent
+        onRunUIFunction={() => {
+          'worklet';
+          const checks = [typeof bigIntValue === 'bigint', bigIntValue === maxInt64 * maxInt64];
+          return checks.every(Boolean);
+        }}
+      />,
+    );
+    await waitForNotification(DONE_NOTIFICATION_NAME);
+
+    // Assert
+    const sharedValue = await getRegisteredValue(RESULT_SHARED_VALUE_REF);
+    expect(sharedValue.onUI).toBe('ok');
+    expect(sharedValue.onJS).toBe('ok');
+  });
+
   test('createSerializableHostObject', async () => {
     // Arrange
-    // @ts-expect-error It's ok
     const hostObjectValue = globalThis.__reanimatedModuleProxy;
     const hostObjectKeys = Object.keys(hostObjectValue);
 
@@ -572,8 +598,7 @@ describe('Test createSerializable', () => {
 
   test('createSerializableHostFunction', async () => {
     // Arrange
-    // @ts-expect-error It's ok
-    const hostFunction = globalThis.__workletsModuleProxy.createSerializableBoolean;
+    const hostFunction = globalThis.__workletsModuleProxy.createSerializableBoolean as any;
 
     // Act
     await render(
@@ -597,7 +622,6 @@ describe('Test createSerializable', () => {
 
   test('createSerializableTurboModuleLike', async () => {
     // Arrange
-    // @ts-expect-error This global host object isn't exposed in the types.
     const proto = globalThis.__reanimatedModuleProxy;
     const reanimatedModuleKeys = Object.keys(proto);
     const obj = {
@@ -751,3 +775,8 @@ describe('Test createSerializable', () => {
     expect(sharedValue.onJS).toBe('error');
   });
 });
+
+declare global {
+  var __reanimatedModuleProxy: Record<string, unknown>;
+  var __workletsModuleProxy: Record<string, unknown>;
+}

apps/common-app/src/apps/reanimated/examples/RuntimeTests/tests/memory/isSerializableRef.test.tsx

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { isSerializableRef, createSerializable } from 'react-native-worklets';
 import { describe, expect, test } from '../../ReJest/RuntimeTestsApi';
 
@@ -151,23 +152,20 @@ describe('Test isSerializableRef', () => {
   });
 
   test('check if createSerializable<host object> returns serializable ref', () => {
-    // @ts-expect-error It's ok
     const hostObjectValue = globalThis.__reanimatedModuleProxy;
     const serializableRef = createSerializable(hostObjectValue);
 
     expect(isSerializableRef(serializableRef)).toBe(true);
   });
 
   test('check if createSerializable<host function> returns serializable ref', () => {
-    // @ts-expect-error It's ok
     const hostFunction = globalThis.__workletsModuleProxy.createSerializableBoolean;
     const serializableRef = createSerializable(hostFunction);
 
     expect(isSerializableRef(serializableRef)).toBe(true);
   });
 
   test('check if createSerializable<TurboModule-like object> returns serializable ref', () => {
-    // @ts-expect-error This global host object isn't exposed in the types.
     const proto = globalThis.__reanimatedModuleProxy;
     const obj = {
       a: 1,

packages/react-native-worklets/Common/cpp/worklets/SharedItems/Serializable.cpp

@@ -441,7 +441,11 @@ jsi::Value SerializableString::toJSValue(jsi::Runtime &rt) {
 }
 
 jsi::Value SerializableBigInt::toJSValue(jsi::Runtime &rt) {
-  return rt.global().getPropertyAsFunction(rt, "BigInt").call(rt, jsi::String::createFromUtf8(rt, string_));
+  if (fastValue_.has_value()) {
+    return jsi::BigInt::fromInt64(rt, fastValue_.value());
+  } else {
+    return rt.global().getPropertyAsFunction(rt, "BigInt").call(rt, jsi::String::createFromUtf8(rt, slowValue_));
+  }
 }
 
 jsi::Value SerializableScalar::toJSValue(jsi::Runtime &) {

packages/react-native-worklets/Common/cpp/worklets/SharedItems/Serializable.h

@@ -364,13 +364,22 @@ class SerializableString : public Serializable {
 
 class SerializableBigInt : public Serializable {
  public:
-  explicit SerializableBigInt(jsi::Runtime &rt, const jsi::BigInt &bigint)
-      : Serializable(ValueType::BigIntType), string_(bigint.toString(rt).utf8(rt)) {}
+  explicit SerializableBigInt(jsi::Runtime &rt, const jsi::BigInt &bigInt) : Serializable(ValueType::BigIntType) {
+    if (bigInt.isInt64(rt)) {
+      fastValue_ = bigInt.getInt64(rt);
+    } else {
+      slowValue_ = bigInt.toString(rt).utf8(rt);
+    }
+  }
 
   jsi::Value toJSValue(jsi::Runtime &rt) override;
 
  protected:
-  const std::string string_;
+  /**
+   * This member is used only when the BigInt fits into int64_t range.
+  */
+  std::optional<int64_t> fastValue_{};
+  std::string slowValue_{};
 };
 
 class SerializableScalar : public Serializable {