fix(Worklets): re-workletizing in bundle mode (#8428)

## Summary

__This change applies only to the Bundle Mode__

Prevent bundle mode re-workletizing already workletized files, i.e.:

```js
// file.js
function callback() {
  scheduleOnUI(callback);
}
```

Produces:

```js
// file.out.js
const callback = require("react-native-worklets/__generatedWorklets/16394205897371.js").default({
  scheduleOnUI
});
```

and

```js
// react-native-worklets/__generatedWorklets/16394205897371.js
export default (function callback_fileJs1Factory({
  scheduleOnUI
}) {
  const callback = function () {
    scheduleOnUI(callback);
  };
  callback.__closure = {
    scheduleOnUI
  };
  callback.__workletHash = 16394205897371;
  return callback;
});
```

and then erroneously transforms it into

```js
// react-native-worklets/__generatedWorklets/16394205897371.out.js
export default (function callback_fileJs1Factory({
  scheduleOnUI
}) {
  const callback = require("react-native-worklets/__generatedWorklets/12241415968957.js").default({
    scheduleOnUI,
    callback
  });
  callback.__closure = {
    scheduleOnUI
  };
  callback.__workletHash = 16394205897371;
  return callback;
});
```

and creates

```js
// react-native-worklets/__generatedWorklets/12241415968957.js
export default (function callback_fileJs1Factory({
  scheduleOnUI
}) {
  const callback = function () {
    scheduleOnUI(callback);
  };
  callback.__closure = {
    scheduleOnUI
  };
  callback.__workletHash = 16394205897371;
  return callback;
});
```

With these changes the transformation of
`react-native-worklets/__generatedWorklets/16394205897371.js` is
idempotent.

## Test plan

Trust me bro 👍

Author: tjzel

packages/react-native-worklets/plugin/babel.config.js

@@ -8,7 +8,7 @@ module.exports = {
     [
       workletsPlugin,
       {
-        // bundleMode true,
+        // bundleMode: true,
       },
     ],
   ],

packages/react-native-worklets/plugin/index.js

@@ -128,7 +128,8 @@ function processArgs(
     const maybeWorklet = findWorklet(
       arg,
       acceptWorkletizableFunction,
-      acceptObject
+      acceptObject,
+      state
     );
     // @ts-expect-error There's no need to workletize
     // inside an already workletized function.
@@ -146,7 +147,8 @@ function processArgs(
 function findWorklet(
   arg: NodePath,
   acceptWorkletizableFunction: boolean,
-  acceptObject: boolean
+  acceptObject: boolean,
+  state: ReanimatedPluginPass
 ): NodePath<WorkletizableFunction> | NodePath<WorkletizableObject> | undefined {
   if (acceptWorkletizableFunction && isWorkletizableFunctionPath(arg)) {
     return arg;
@@ -158,7 +160,8 @@ function findWorklet(
     return findReferencedWorklet(
       arg,
       acceptWorkletizableFunction,
-      acceptObject
+      acceptObject,
+      state
     );
   }
   return undefined;

packages/react-native-worklets/plugin/src/autoworkletization.ts

@@ -1,8 +1,13 @@
 import type { NodePath } from '@babel/core';
 import type { Binding } from '@babel/traverse';
 import type { AssignmentExpression, Identifier } from '@babel/types';
+import { isIdentifier, isMemberExpression } from '@babel/types';
 
-import type { WorkletizableFunction, WorkletizableObject } from './types';
+import type {
+  ReanimatedPluginPass,
+  WorkletizableFunction,
+  WorkletizableObject,
+} from './types';
 import {
   isWorkletizableFunctionPath,
   isWorkletizableObjectPath,
@@ -11,7 +16,8 @@ import {
 export function findReferencedWorklet(
   workletIdentifier: NodePath<Identifier>,
   acceptWorkletizableFunction: boolean,
-  acceptObject: boolean
+  acceptObject: boolean,
+  state: ReanimatedPluginPass
 ): NodePath<WorkletizableFunction> | NodePath<WorkletizableObject> | undefined {
   const workletName = workletIdentifier.node.name;
   const scope = workletIdentifier.scope;
@@ -21,6 +27,10 @@ export function findReferencedWorklet(
     return undefined;
   }
 
+  if (state.opts.bundleMode && bindingIsWorklet(workletBinding)) {
+    return undefined;
+  }
+
   if (
     acceptWorkletizableFunction &&
     workletBinding.path.isFunctionDeclaration()
@@ -33,20 +43,23 @@ export function findReferencedWorklet(
     return findReferencedWorkletFromVariableDeclarator(
       workletBinding,
       acceptWorkletizableFunction,
-      acceptObject
+      acceptObject,
+      state
     );
   }
   return findReferencedWorkletFromAssignmentExpression(
     workletBinding,
     acceptWorkletizableFunction,
-    acceptObject
+    acceptObject,
+    state
   );
 }
 
 function findReferencedWorkletFromVariableDeclarator(
   workletBinding: Binding,
   acceptWorkletizableFunction: boolean,
-  acceptObject: boolean
+  acceptObject: boolean,
+  state: ReanimatedPluginPass
 ): NodePath<WorkletizableFunction> | NodePath<WorkletizableObject> | undefined {
   const workletDeclaration = workletBinding.path;
   if (!workletDeclaration.isVariableDeclarator()) {
@@ -64,7 +77,8 @@ function findReferencedWorkletFromVariableDeclarator(
     return findReferencedWorklet(
       worklet,
       acceptWorkletizableFunction,
-      acceptObject
+      acceptObject,
+      state
     );
   }
   return undefined;
@@ -73,7 +87,8 @@ function findReferencedWorkletFromVariableDeclarator(
 function findReferencedWorkletFromAssignmentExpression(
   workletBinding: Binding,
   acceptWorkletizableFunction: boolean,
-  acceptObject: boolean
+  acceptObject: boolean,
+  state: ReanimatedPluginPass
 ): NodePath<WorkletizableFunction> | NodePath<WorkletizableObject> | undefined {
   const workletDeclaration = workletBinding.constantViolations
     .reverse()
@@ -108,8 +123,20 @@ function findReferencedWorkletFromAssignmentExpression(
     return findReferencedWorklet(
       workletDefinition,
       acceptWorkletizableFunction,
-      acceptObject
+      acceptObject,
+      state
     );
   }
   return undefined;
 }
+
+function bindingIsWorklet(binding: Binding) {
+  return binding.referencePaths.some(
+    (refPath) =>
+      !Array.isArray(refPath.container) &&
+      isMemberExpression(refPath.container) &&
+      refPath.container.object === refPath.node &&
+      isIdentifier(refPath.container.property) &&
+      refPath.container.property.name === '__workletHash'
+  );
+}