feat(Worklets): always compile bundle mode symbols (#9064)

## Summary

This PR is a step that makes experimental Bundle Mode less experimental.

Having the use of Bundle Mode gated behind #ifdef macros is burdensome
for prebuild environments or large scale apps.

This PR makes it so the native side receives the information whether to
use the Bundle Mode from JavaScript, instead from static feature flags.
All Bundle Mode symbols are available without re-compilation, resulting
in much faster toggling of the feature.

The source of truth for whether the Bundle Mode is enabled is the
`babel.config.js` - passing `bundleMode: true` in the config enables the
bundle mode.

## Test plan

Compiled and ran the example app both with and without the Bundle Mode.

Author: tjzel

apps/fabric-example/ios/Podfile.lock

@@ -12,6 +12,7 @@
 #include <worklets/Tools/Defs.h>
 #include <worklets/Tools/FeatureFlags.h>
 #include <worklets/Tools/JSLogger.h>
+#include <worklets/WorkletRuntime/BundleModeConfig.h>
 #include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
 
 #include <memory>
@@ -87,22 +88,20 @@ inline jsi::Value createWorkletRuntime(
   return jsi::Object::createFromHostObject(originRuntime, workletRuntime);
 }
 
-#ifdef WORKLETS_BUNDLE_MODE_ENABLED
 inline jsi::Value propagateModuleUpdate(
     const std::shared_ptr<RuntimeManager> &runtimeManager,
     const std::string &code,
     const std::string &sourceUrl) {
   const auto runtimes = runtimeManager->getAllRuntimes();
 
-  for (auto runtime : runtimes) {
+  for (const auto &runtime : runtimes) {
     runtime->runSync([code, sourceUrl](jsi::Runtime &rt) -> void {
       const auto buffer = std::make_shared<jsi::StringBuffer>(code);
       rt.evaluateJavaScript(buffer, sourceUrl);
     });
   }
   return jsi::Value::undefined();
 }
-#endif // WORKLETS_BUNDLE_MODE_ENABLED
 
 inline jsi::Value reportFatalErrorOnJS(
     const std::shared_ptr<JSScheduler> &jsScheduler,
@@ -152,19 +151,17 @@ inline void registerCustomSerializable(
 
 JSIWorkletsModuleProxy::JSIWorkletsModuleProxy(
     const bool isDevBundle,
-    const std::shared_ptr<const ScriptBuffer> &script,
-    const std::string &sourceUrl,
     const std::shared_ptr<MessageQueueThread> &jsQueue,
     const std::shared_ptr<JSScheduler> &jsScheduler,
     const std::shared_ptr<UIScheduler> &uiScheduler,
     const std::shared_ptr<MemoryManager> &memoryManager,
     const std::shared_ptr<RuntimeManager> &runtimeManager,
     const std::weak_ptr<WorkletRuntime> &uiWorkletRuntime,
-    const std::shared_ptr<RuntimeBindings> &runtimeBindings)
+    const std::shared_ptr<RuntimeBindings> &runtimeBindings,
+    const BundleModeConfig &bundleModeConfig)
     : jsi::HostObject(),
       isDevBundle_(isDevBundle),
-      script_(script),
-      sourceUrl_(sourceUrl),
+      bundleModeConfig_(bundleModeConfig),
       jsQueue_(jsQueue),
       jsScheduler_(jsScheduler),
       uiScheduler_(uiScheduler),
@@ -219,9 +216,7 @@ std::vector<jsi::PropNameID> JSIWorkletsModuleProxy::getPropertyNames(jsi::Runti
 
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "createShareable"));
 
-#ifdef WORKLETS_BUNDLE_MODE_ENABLED
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "propagateModuleUpdate"));
-#endif // WORKLETS_BUNDLE_MODE_ENABLED
 
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "getUIRuntimeHolder"));
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "getUISchedulerHolder"));
@@ -579,7 +574,6 @@ jsi::Value JSIWorkletsModuleProxy::get(jsi::Runtime &rt, const jsi::PropNameID &
         });
   }
 
-#ifdef WORKLETS_BUNDLE_MODE_ENABLED
   if (name == "propagateModuleUpdate") {
     return jsi::Function::createFromHostFunction(
         rt,
@@ -593,7 +587,6 @@ jsi::Value JSIWorkletsModuleProxy::get(jsi::Runtime &rt, const jsi::PropNameID &
               /* sourceURL */ args[1].asString(rt).utf8(rt));
         });
   }
-#endif // WORKLETS_BUNDLE_MODE_ENABLED
 
   if (name == "getStaticFeatureFlag") {
     return jsi::Function::createFromHostFunction(

apps/macos-example/macos/Podfile.lock

@@ -8,6 +8,7 @@
 #include <worklets/SharedItems/Serializable.h>
 #include <worklets/Tools/Defs.h>
 #include <worklets/Tools/ScriptBuffer.h>
+#include <worklets/WorkletRuntime/BundleModeConfig.h>
 #include <worklets/WorkletRuntime/RuntimeBindings.h>
 #include <worklets/WorkletRuntime/RuntimeManager.h>
 #include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
@@ -26,15 +27,14 @@ class JSIWorkletsModuleProxy : public jsi::HostObject {
  public:
   explicit JSIWorkletsModuleProxy(
       const bool isDevBundle,
-      const std::shared_ptr<const ScriptBuffer> &script,
-      const std::string &sourceUrl,
       const std::shared_ptr<MessageQueueThread> &jsQueue,
       const std::shared_ptr<JSScheduler> &jsScheduler,
       const std::shared_ptr<UIScheduler> &uiScheduler,
       const std::shared_ptr<MemoryManager> &memoryManager,
       const std::shared_ptr<RuntimeManager> &runtimeManager,
       const std::weak_ptr<WorkletRuntime> &uiWorkletRuntime,
-      const std::shared_ptr<RuntimeBindings> &runtimeBindings);
+      const std::shared_ptr<RuntimeBindings> &runtimeBindings,
+      const BundleModeConfig &bundleModeConfig);
 
   JSIWorkletsModuleProxy(const JSIWorkletsModuleProxy &other) = default;
 
@@ -56,16 +56,20 @@ class JSIWorkletsModuleProxy : public jsi::HostObject {
     return uiScheduler_;
   }
 
+  [[nodiscard]] bool isBundleModeEnabled() const {
+    return bundleModeConfig_.enabled;
+  }
+
   [[nodiscard]] bool isDevBundle() const {
     return isDevBundle_;
   }
 
   [[nodiscard]] std::shared_ptr<const ScriptBuffer> getScript() const {
-    return script_;
+    return bundleModeConfig_.script;
   }
 
   [[nodiscard]] std::string getSourceUrl() const {
-    return sourceUrl_;
+    return bundleModeConfig_.sourceURL;
   }
 
   [[nodiscard]] std::shared_ptr<MemoryManager> getMemoryManager() const {
@@ -82,8 +86,7 @@ class JSIWorkletsModuleProxy : public jsi::HostObject {
 
  private:
   const bool isDevBundle_;
-  const std::shared_ptr<const ScriptBuffer> script_;
-  const std::string sourceUrl_;
+  const BundleModeConfig bundleModeConfig_;
   const std::shared_ptr<MessageQueueThread> jsQueue_;
   const std::shared_ptr<JSScheduler> jsScheduler_;
   const std::shared_ptr<UIScheduler> uiScheduler_;

apps/tvos-example/ios/Podfile.lock

@@ -1,6 +1,5 @@
 #include <react/renderer/uimanager/UIManagerBinding.h>
 #include <react/renderer/uimanager/primitives.h>
-
 #include <worklets/NativeModules/WorkletsModuleProxy.h>
 #include <worklets/RunLoop/AsyncQueueImpl.h>
 #include <worklets/SharedItems/Serializable.h>
@@ -9,19 +8,14 @@
 #include <worklets/WorkletRuntime/RuntimeBindings.h>
 #include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
 
-#ifdef __ANDROID__
-#include <fbjni/fbjni.h>
-#endif // __ANDROID__
-
 #include <memory>
-#include <string>
 #include <utility>
 
 using namespace facebook;
 
 namespace worklets {
 
-auto isDevBundleFromRNRuntime(jsi::Runtime &rnRuntime) -> bool;
+bool isDevBundleFromRNRuntime(jsi::Runtime &rnRuntime);
 
 WorkletsModuleProxy::WorkletsModuleProxy(
     jsi::Runtime &rnRuntime,
@@ -30,16 +24,14 @@ WorkletsModuleProxy::WorkletsModuleProxy(
     const std::shared_ptr<UIScheduler> &uiScheduler,
     std::function<bool()> &&isJavaScriptThread,
     const std::shared_ptr<RuntimeBindings> &runtimeBindings,
-    const std::shared_ptr<const ScriptBuffer> &script,
-    const std::string &sourceUrl)
+    const BundleModeConfig &bundleModeConfig)
     : isDevBundle_(isDevBundleFromRNRuntime(rnRuntime)),
       jsQueue_(jsQueue),
       jsScheduler_(std::make_shared<JSScheduler>(rnRuntime, jsCallInvoker, std::move(isJavaScriptThread))),
       uiScheduler_(uiScheduler),
       jsLogger_(std::make_shared<JSLogger>(jsScheduler_)),
       runtimeBindings_(runtimeBindings),
-      script_(script),
-      sourceUrl_(sourceUrl),
+      bundleModeConfig_(bundleModeConfig),
       memoryManager_(std::make_shared<MemoryManager>()),
       runtimeManager_(std::make_shared<RuntimeManager>()),
       uiWorkletRuntime_(
@@ -61,15 +53,14 @@ std::shared_ptr<JSIWorkletsModuleProxy> WorkletsModuleProxy::createJSIWorkletsMo
   assert(uiWorkletRuntime_ && "UI Worklet Runtime must be initialized before creating JSI proxy.");
   return std::make_shared<JSIWorkletsModuleProxy>(
       isDevBundle_,
-      script_,
-      sourceUrl_,
       jsQueue_,
       jsScheduler_,
       uiScheduler_,
       memoryManager_,
       runtimeManager_,
       uiWorkletRuntime_,
-      runtimeBindings_);
+      runtimeBindings_,
+      bundleModeConfig_);
 }
 
 WorkletsModuleProxy::~WorkletsModuleProxy() {

packages/react-native-worklets/Common/cpp/worklets/NativeModules/JSIWorkletsModuleProxy.cpp

@@ -12,11 +12,11 @@
 #include <worklets/Tools/ScriptBuffer.h>
 #include <worklets/Tools/SingleInstanceChecker.h>
 #include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/BundleModeConfig.h>
 #include <worklets/WorkletRuntime/RuntimeManager.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 
 #include <memory>
-#include <string>
 
 namespace worklets {
 
@@ -29,8 +29,7 @@ class WorkletsModuleProxy : public std::enable_shared_from_this<WorkletsModulePr
       const std::shared_ptr<UIScheduler> &uiScheduler,
       std::function<bool()> &&isJavaScriptQueue,
       const std::shared_ptr<RuntimeBindings> &runtimeBindings,
-      const std::shared_ptr<const ScriptBuffer> &script,
-      const std::string &sourceUrl);
+      const BundleModeConfig &bundleModeConfig);
 
   ~WorkletsModuleProxy();
 
@@ -67,8 +66,7 @@ class WorkletsModuleProxy : public std::enable_shared_from_this<WorkletsModulePr
   const std::shared_ptr<UIScheduler> uiScheduler_;
   const std::shared_ptr<JSLogger> jsLogger_;
   const std::shared_ptr<RuntimeBindings> runtimeBindings_;
-  const std::shared_ptr<const ScriptBuffer> script_;
-  const std::string sourceUrl_;
+  const BundleModeConfig bundleModeConfig_;
   const std::shared_ptr<MemoryManager> memoryManager_;
   const std::shared_ptr<RuntimeManager> runtimeManager_;
   std::shared_ptr<WorkletRuntime> uiWorkletRuntime_;

packages/react-native-worklets/Common/cpp/worklets/NativeModules/JSIWorkletsModuleProxy.h

@@ -1,15 +1,10 @@
 #pragma once
 
-/*
-On Android JS_RUNTIME_HERMES is set in CMakeList.txt,
-but on iOS there is no simple way to defect if Hermes exists
-so we have to check if headers are available.
-*/
 #if __APPLE__ && __has_include(<hermes/hermes.h>)
 #define JS_RUNTIME_HERMES 1
 #endif
 
-#if REACT_NATIVE_MINOR_VERSION >= 84 || defined(WORKLETS_BUNDLE_MODE_ENABLED)
+#if REACT_NATIVE_MINOR_VERSION >= 84
 #include <cxxreact/JSBigString.h>
 namespace worklets {
 using JSBigStringBuffer = facebook::react::JSBigString;
@@ -19,4 +14,4 @@ using JSBigStringBuffer = facebook::react::JSBigString;
 namespace worklets {
 using JSBigStringBuffer = facebook::react::BigStringBuffer;
 }
-#endif // REACT_NATIVE_MINOR_VERSION >= 84 || defined(WORKLETS_BUNDLE_MODE_ENABLED)
+#endif // REACT_NATIVE_MINOR_VERSION >= 84

packages/react-native-worklets/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.cpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <cxxreact/JSBigString.h>
 #include <jsi/jsi.h>
+#include <worklets/Tools/Defs.h>
 
 #include <memory>
 #include <utility>

packages/react-native-worklets/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Tools/ScriptBuffer.h>
+
+#include <memory>
+#include <string>
+
+namespace worklets {
+
+struct BundleModeConfig {
+  bool enabled;
+  std::shared_ptr<const ScriptBuffer> script;
+  std::string sourceURL;
+};
+
+} // namespace worklets