feat: add bundleId

React/CxxBridge/RCTCxxBridge.mm

@@ -384,7 +384,7 @@ - (void)start
   dispatch_group_notify(prepareBridge, dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^{
     RCTCxxBridge *strongSelf = weakSelf;
     if (sourceCode && strongSelf.loading) {
-      [strongSelf executeSourceCode:sourceCode sync:NO];
+      [strongSelf executeSourceCode:sourceCode bundleId:0 sync:NO];
     }
   });
   RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
@@ -880,7 +880,7 @@ - (void)registerModuleForFrameUpdates:(id<RCTBridgeModule>)module
   [_displayLink registerModuleForFrameUpdates:module withModuleData:moduleData];
 }
 
-- (void)executeSourceCode:(NSData *)sourceCode sync:(BOOL)sync
+- (void)executeSourceCode:(NSData *)sourceCode bundleId:(int)bundleId sync:(BOOL)sync
 {
   // This will get called from whatever thread was actually executing JS.
   dispatch_block_t completion = ^{
@@ -905,10 +905,10 @@ - (void)executeSourceCode:(NSData *)sourceCode sync:(BOOL)sync
   };
 
   if (sync) {
-    [self executeApplicationScriptSync:sourceCode url:self.bundleURL];
+    [self executeApplicationScriptSync:sourceCode url:self.bundleURL bundleId:bundleId];
     completion();
   } else {
-    [self enqueueApplicationScript:sourceCode url:self.bundleURL onComplete:completion];
+    [self enqueueApplicationScript:sourceCode url:self.bundleURL bundleId:bundleId onComplete:completion];
   }
 
   if (self.devSettings.isHotLoadingAvailable) {
@@ -1292,11 +1292,12 @@ - (void)_immediatelyCallTimer:(NSNumber *)timer
 
 - (void)enqueueApplicationScript:(NSData *)script
                              url:(NSURL *)url
+                             bundleId:(uint32_t)bundleId
                       onComplete:(dispatch_block_t)onComplete
 {
   RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, @"-[RCTCxxBridge enqueueApplicationScript]", nil);
 
-  [self executeApplicationScript:script url:url async:YES];
+  [self executeApplicationScript:script url:url bundleId:bundleId async:YES];
 
   RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
 
@@ -1307,13 +1308,14 @@ - (void)enqueueApplicationScript:(NSData *)script
   }
 }
 
-- (void)executeApplicationScriptSync:(NSData *)script url:(NSURL *)url
+- (void)executeApplicationScriptSync:(NSData *)script url:(NSURL *)url bundleId:(uint32_t)bundleId
 {
-  [self executeApplicationScript:script url:url async:NO];
+  [self executeApplicationScript:script url:url bundleId:bundleId async:NO];
 }
 
 - (void)executeApplicationScript:(NSData *)script
                              url:(NSURL *)url
+                             bundleId:(uint32_t)bundleId
                            async:(BOOL)async
 {
   [self _tryAndHandleError:^{
@@ -1329,7 +1331,7 @@ - (void)executeApplicationScript:(NSData *)script
       [self->_performanceLogger setValue:scriptStr->size() forTag:RCTPLRAMStartupCodeSize];
       if (self->_reactInstance) {
         self->_reactInstance->loadRAMBundle(std::move(ramBundle), std::move(scriptStr),
-                                            sourceUrlStr.UTF8String, !async);
+                                            sourceUrlStr.UTF8String, bundleId, !async);
       }
     } else if (self->_reactInstance) {
       self->_reactInstance->loadScriptFromString(std::make_unique<NSDataBigString>(script),

ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstanceImpl.java

@@ -230,26 +230,26 @@ public void registerSegment(int segmentId, String path) {
 
   @Override
   public void loadScriptFromAssets(
-      AssetManager assetManager, String assetURL, boolean loadSynchronously) {
+      AssetManager assetManager, String assetURL, int bundleId, boolean loadSynchronously) {
     mSourceURL = assetURL;
-    jniLoadScriptFromAssets(assetManager, assetURL, loadSynchronously);
+    jniLoadScriptFromAssets(assetManager, assetURL, bundleId, loadSynchronously);
   }
 
   @Override
-  public void loadScriptFromFile(String fileName, String sourceURL, boolean loadSynchronously) {
+  public void loadScriptFromFile(String fileName, String sourceURL, int bundleId, boolean loadSynchronously) {
     mSourceURL = sourceURL;
-    jniLoadScriptFromFile(fileName, sourceURL, loadSynchronously);
+    jniLoadScriptFromFile(fileName, sourceURL, bundleId, loadSynchronously);
   }
 
   private native void jniSetSourceURL(String sourceURL);
 
   private native void jniRegisterSegment(int segmentId, String path);
 
   private native void jniLoadScriptFromAssets(
-      AssetManager assetManager, String assetURL, boolean loadSynchronously);
+      AssetManager assetManager, String assetURL, int bundleId, boolean loadSynchronously);
 
   private native void jniLoadScriptFromFile(
-      String fileName, String sourceURL, boolean loadSynchronously);
+      String fileName, String sourceURL, int bundleId, boolean loadSynchronously);
 
   @Override
   public void runJSBundle() {

ReactAndroid/src/main/java/com/facebook/react/bridge/JSBundleLoader.java

@@ -26,7 +26,7 @@ public static JSBundleLoader createAssetLoader(
     return new JSBundleLoader() {
       @Override
       public String loadScript(JSBundleLoaderDelegate delegate) {
-        delegate.loadScriptFromAssets(context.getAssets(), assetUrl, loadSynchronously);
+        delegate.loadScriptFromAssets(context.getAssets(), assetUrl, 0, loadSynchronously);
         return assetUrl;
       }
     };
@@ -45,7 +45,7 @@ public static JSBundleLoader createFileLoader(
     return new JSBundleLoader() {
       @Override
       public String loadScript(JSBundleLoaderDelegate delegate) {
-        delegate.loadScriptFromFile(fileName, assetUrl, loadSynchronously);
+        delegate.loadScriptFromFile(fileName, assetUrl, 0, loadSynchronously);
         return fileName;
       }
     };
@@ -64,7 +64,7 @@ public static JSBundleLoader createCachedBundleFromNetworkLoader(
       @Override
       public String loadScript(JSBundleLoaderDelegate delegate) {
         try {
-          delegate.loadScriptFromFile(cachedFileLocation, sourceURL, false);
+          delegate.loadScriptFromFile(cachedFileLocation, sourceURL, 0, false);
           return sourceURL;
         } catch (Exception e) {
           throw DebugServerException.makeGeneric(sourceURL, e.getMessage(), e);

ReactAndroid/src/main/java/com/facebook/react/bridge/JSBundleLoaderDelegate.java

@@ -19,19 +19,21 @@ public interface JSBundleLoaderDelegate {
    *
    * @param assetManager
    * @param assetURL
+   * @param bundleId
    * @param loadSynchronously
    */
-  void loadScriptFromAssets(AssetManager assetManager, String assetURL, boolean loadSynchronously);
+  void loadScriptFromAssets(AssetManager assetManager, String assetURL, int bundleId, boolean loadSynchronously);
 
   /**
    * Load a JS bundle from the filesystem. See {@link JSBundleLoader#createFileLoader(String)} and
    * {@link JSBundleLoader#createCachedBundleFromNetworkLoader(String, String)}
    *
    * @param fileName
    * @param sourceURL
+   * @param bundleId
    * @param loadSynchronously
    */
-  void loadScriptFromFile(String fileName, String sourceURL, boolean loadSynchronously);
+  void loadScriptFromFile(String fileName, String sourceURL, int bundleId, boolean loadSynchronously);
 
   /**
    * This API is used in situations where the JS bundle is being executed not on the device, but on

ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.cpp

@@ -208,6 +208,7 @@ void CatalystInstanceImpl::jniRegisterSegment(
 void CatalystInstanceImpl::jniLoadScriptFromAssets(
     jni::alias_ref<JAssetManager::javaobject> assetManager,
     const std::string &assetURL,
+    int bundleId,
     bool loadSynchronously) {
   const int kAssetsLength = 9; // strlen("assets://");
   auto sourceURL = assetURL.substr(kAssetsLength);
@@ -217,10 +218,10 @@ void CatalystInstanceImpl::jniLoadScriptFromAssets(
   if (JniJSModulesUnbundle::isUnbundle(manager, sourceURL)) {
     auto bundle = JniJSModulesUnbundle::fromEntryFile(manager, sourceURL);
     instance_->loadRAMBundle(
-        std::move(bundle), std::move(script), sourceURL, loadSynchronously);
+        std::move(bundle), std::move(script), sourceURL, (uint32_t)bundleId, loadSynchronously);
     return;
   } else if (Instance::isIndexedRAMBundle(&script)) {
-    instance_->loadRAMBundleFromString(std::move(script), sourceURL);
+    instance_->loadRAMBundleFromString(std::move(script), sourceURL, (uint32_t)bundleId);
   } else {
     instance_->loadScriptFromString(
         std::move(script), sourceURL, loadSynchronously);
@@ -230,9 +231,10 @@ void CatalystInstanceImpl::jniLoadScriptFromAssets(
 void CatalystInstanceImpl::jniLoadScriptFromFile(
     const std::string &fileName,
     const std::string &sourceURL,
+    int bundleId,
     bool loadSynchronously) {
   if (Instance::isIndexedRAMBundle(fileName.c_str())) {
-    instance_->loadRAMBundleFromFile(fileName, sourceURL, loadSynchronously);
+    instance_->loadRAMBundleFromFile(fileName, sourceURL, (uint32_t)bundleId, loadSynchronously);
   } else {
     std::unique_ptr<const JSBigFileString> script;
     RecoverableError::runRethrowingAsRecoverable<std::system_error>(

ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.h

@@ -77,15 +77,14 @@ class CatalystInstanceImpl : public jni::HybridClass<CatalystInstanceImpl> {
    *
    */
   void jniRegisterSegment(int segmentId, const std::string &path);
-
-  void jniLoadScriptFromAssets(
-      jni::alias_ref<JAssetManager::javaobject> assetManager,
-      const std::string &assetURL,
-      bool loadSynchronously);
-  void jniLoadScriptFromFile(
-      const std::string &fileName,
-      const std::string &sourceURL,
-      bool loadSynchronously);
+  void jniLoadScriptFromAssets(jni::alias_ref<JAssetManager::javaobject> assetManager,
+                               const std::string& assetURL,
+                               int bundleId,
+                               bool loadSynchronously);
+  void jniLoadScriptFromFile(const std::string& fileName,
+                             const std::string& sourceURL,
+                             int bundleId,
+                             bool loadSynchronously);
   void jniCallJSFunction(
       std::string module,
       std::string method,

ReactCommon/cxxreact/Instance.cpp

@@ -120,31 +120,40 @@ bool Instance::isIndexedRAMBundle(std::unique_ptr<const JSBigString> *script) {
 
 void Instance::loadRAMBundleFromString(
     std::unique_ptr<const JSBigString> script,
-    const std::string &sourceURL) {
+    const std::string& sourceURL,
+    uint32_t bundleId) {
   auto bundle = std::make_unique<JSIndexedRAMBundle>(std::move(script));
   auto startupScript = bundle->getStartupCode();
-  loadRAMBundle(std::move(bundle), std::move(startupScript), sourceURL, true);
+  loadRAMBundle(
+      std::move(bundle),
+      std::move(startupScript),
+      sourceURL,
+      bundleId,
+      true);
 }
 
 void Instance::loadRAMBundleFromFile(
     const std::string &sourcePath,
     const std::string &sourceURL,
+    uint32_t bundleId,
     bool loadSynchronously) {
   auto bundle = std::make_unique<JSIndexedRAMBundle>(sourcePath.c_str());
   auto startupScript = bundle->getStartupCode();
   loadRAMBundle(
       std::move(bundle),
       std::move(startupScript),
       sourceURL,
+      bundleId,
       loadSynchronously);
 }
 
 void Instance::loadRAMBundle(
     std::unique_ptr<JSModulesUnbundle> bundle,
     std::unique_ptr<const JSBigString> startupScript,
     std::string startupScriptSourceURL,
+    uint32_t bundleId,
     bool loadSynchronously) {
-  nativeToJsBridge_->registerBundle(0, std::move(bundle));
+  nativeToJsBridge_->registerBundle(bundleId, std::move(bundle));
   if (loadSynchronously) {
     loadBundleSync(
         std::move(startupScript),

ReactCommon/cxxreact/Instance.h

@@ -52,13 +52,18 @@ class RN_EXPORT Instance {
                             std::string sourceURL, bool loadSynchronously);
   static bool isIndexedRAMBundle(const char *sourcePath);
   static bool isIndexedRAMBundle(std::unique_ptr<const JSBigString>* string);
-  void loadRAMBundleFromString(std::unique_ptr<const JSBigString> script, const std::string& sourceURL);
+  void loadRAMBundleFromString(std::unique_ptr<const JSBigString> script,
+                               const std::string& sourceURL,
+                               uint32_t bundleId);
   void loadRAMBundleFromFile(const std::string& sourcePath,
                              const std::string& sourceURL,
+                             uint32_t bundleId,
                              bool loadSynchronously);
   void loadRAMBundle(std::unique_ptr<JSModulesUnbundle> bundle,
                      std::unique_ptr<const JSBigString> startupScript,
-                     std::string startupScriptSourceURL, bool loadSynchronously);
+                     std::string startupScriptSourceURL,
+                     uint32_t bundleId,
+                     bool loadSynchronously);
   bool supportsProfiling();
   void setGlobalVariable(std::string propName,
                          std::unique_ptr<const JSBigString> jsonValue);