fix(Worklets): Bundle Mode accidentally toggling in Expo54 (#8335)

## Summary

Expo 54 performs eager imports contrary to Metro which is lazy. This
results in `workletRuntimeEntry.ts` file to be executed and for the
`globalThis._WORKLETS_BUNDLE_MODE` flag to be set wrongfully to `true`.

To handle both eager and lazy imports environments I decided to handle
the setting of the flag's value in Worklets Babel Plugin. Worklets Babel
Plugin makes it so the expression in `workletRuntimeEntry.ts`:

```ts
globalThis._WORKLETS_BUNDLE_MODE = false
```

becomes

```ts
globalThis._WORKLETS_BUNDLE_MODE = true
``` 

when Bundle Mode is enabled.

## Test plan

I tested these changes with an Expo 54 app and they worked.

Author: tjzel

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

@@ -0,0 +1,54 @@
+import type { NodePath } from '@babel/core';
+import { booleanLiteral, type ExpressionStatement } from '@babel/types';
+
+import type { ReanimatedPluginPass } from './types';
+
+/**
+ * This function replaces the `false` value in
+ *
+ * `globalThis._WORKLETS_BUNDLE_MODE = false;`
+ *
+ * With `true` in the `workletRuntimeEntry` file when the `bundleMode` option is
+ * enabled in the Babel plugin.
+ *
+ * This way Bundle Mode is not accidentally set up in eager import environments,
+ */
+export function toggleBundleMode(
+  path: NodePath<ExpressionStatement>,
+  state: ReanimatedPluginPass
+) {
+  if (
+    !state.opts.bundleMode ||
+    !state.filename?.includes('workletRuntimeEntry')
+  ) {
+    return;
+  }
+
+  const expressionPath = path.get('expression');
+
+  if (!expressionPath.isAssignmentExpression()) {
+    return;
+  }
+
+  const left = expressionPath.get('left');
+
+  if (!left.isMemberExpression()) {
+    return;
+  }
+
+  const object = left.get('object');
+  const property = left.get('property');
+
+  if (
+    !object.isIdentifier() ||
+    object.node.name !== 'globalThis' ||
+    !property.isIdentifier() ||
+    property.node.name !== '_WORKLETS_BUNDLE_MODE'
+  ) {
+    return;
+  }
+
+  const right = expressionPath.get('right');
+
+  right.replaceWith(booleanLiteral(true));
+}

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

@@ -2,6 +2,7 @@ import type { NodePath, PluginItem } from '@babel/core';
 import type {
   CallExpression,
   ClassDeclaration,
+  ExpressionStatement,
   JSXAttribute,
   ObjectExpression,
   Program,
@@ -11,6 +12,7 @@ import {
   processCalleesAutoworkletizableCallbacks,
   processIfAutoworkletizableCallback,
 } from './autoworkletization';
+import { toggleBundleMode } from './bundleMode';
 import { processIfWorkletClass } from './class';
 import { processIfWorkletContextObject } from './contextObject';
 import { processIfWorkletFile } from './file';
@@ -85,6 +87,16 @@ module.exports = function WorkletsBabelPlugin(): PluginItem {
           });
         },
       },
+      ExpressionStatement: {
+        enter(
+          path: NodePath<ExpressionStatement>,
+          state: ReanimatedPluginPass
+        ) {
+          runWithTaggedExceptions(() => {
+            toggleBundleMode(path, state);
+          });
+        },
+      },
       JSXAttribute: {
         enter(path: NodePath<JSXAttribute>, state: ReanimatedPluginPass) {
           runWithTaggedExceptions(() =>

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

@@ -18,12 +18,14 @@ import { WorkletsError } from './WorkletsError';
  * `_WORKLETS_BUNDLE_MODE` flag.
  */
 export function bundleModeInit() {
-  if (SHOULD_BE_USE_WEB) {
+  // Worklets Babel Plugin replaces `false` with `true` here
+  // when Bundle Mode is enabled.
+  globalThis._WORKLETS_BUNDLE_MODE = false;
+
+  if (SHOULD_BE_USE_WEB || !globalThis._WORKLETS_BUNDLE_MODE) {
     return;
   }
 
-  globalThis._WORKLETS_BUNDLE_MODE = true;
-
   const runtimeKind = globalThis.__RUNTIME_KIND;
   if (runtimeKind && runtimeKind !== RuntimeKind.ReactNative) {
     /**