@bm-fe/react-native-multi-bundle 1.0.0-beta.4 → 1.0.0-beta.5

package/INTEGRATION.md

@@ -120,25 +120,90 @@ class MainApplication : Application(), ReactApplication {
 
 </details>
 
-### iOS
+### iOS（自动链接，无需手动配置）
 
-#### 1. 复制 Native 模块文件
+#### 自动链接工作原理
+
+安装包后，React Native CLI 和 CocoaPods 会自动：
+1. 读取包中的 `react-native-multi-bundle.podspec`
+2. 将 `ModuleLoader` 原生模块添加到项目中
+3. 在构建时自动集成
+
+#### 安装依赖
+
+安装 npm 包后，运行 pod install：
+
+```bash
+cd ios && pod install
+```
+
+#### 验证自动链接
+
+安装包后，可以通过以下命令验证自动链接是否生效：
+
+```bash
+npx react-native config
+```
+
+在输出中应该能看到 `@bm-fe/react-native-multi-bundle` 的 iOS 配置信息。
+
+#### 准备 Bundles 目录
+
+确保 iOS 项目中有 `Bundles` 目录用于存放 bundle 文件：
+
+1. 在 Xcode 中，右键点击项目 → New Group，创建 `Bundles` 目录
+2. 或者在终端中创建：
+   ```bash
+   mkdir -p ios/YourProject/Bundles/modules
+   ```
 
-将以下文件从 `templates/native/ios/` 添加到你的 iOS 项目：
+3. **重要**：确保 `Bundles` 目录已添加到 Xcode 项目的 Resources 中：
+   - 在 Xcode 中，右键点击 `Bundles` 目录 → Add Files to "YourProject"
+   - 确保 "Create folder references" 已选中（蓝色文件夹图标）
+   - 这样 bundle 文件才会被打包到 app 中
+
+#### Bundle 文件结构
+
+构建完成后，iOS bundle 文件应放置在：
+
+```
+ios/YourProject/Bundles/
+├── bundle-manifest.json
+├── main.jsbundle
+└── modules/
+    ├── home.jsbundle
+    ├── details.jsbundle
+    └── settings.jsbundle
+```
+
+#### 手动集成（可选，仅在自动链接不工作时使用）
+
+<details>
+<summary>点击展开手动集成步骤</summary>
+
+##### 1. 复制 Native 模块文件
+
+将以下文件从 `node_modules/@bm-fe/react-native-multi-bundle/ios/ModuleLoader/` 复制到你的 iOS 项目：
 
 - `ModuleLoaderModule.h`
-- `ModuleLoaderModule.m`
+- `ModuleLoaderModule.mm`
 
 在 Xcode 中：
 1. 右键点击项目 → Add Files to "YourProject"
 2. 选择这两个文件
 3. 确保 "Copy items if needed" 已勾选
 
-#### 2. 注册模块
+##### 2. 验证编译
 
 iOS 端的模块会自动注册（通过 `RCT_EXPORT_MODULE`），无需额外配置。
 
-**注意**：iOS 端的 bundle 加载实现可能需要根据你的具体需求调整。当前模板提供了基础框架。
+重新构建项目：
+
+```bash
+npx react-native run-ios
+```
+
+</details>
 
 ## 初始化多 Bundle 系统
 

package/ios/ModuleLoader/ModuleLoaderModule.h

@@ -0,0 +1,12 @@
+#import <React/RCTBridgeModule.h>
+
+/**
+ * ModuleLoader - iOS 原生模块
+ * 用于在同一个 JS 运行时中动态加载子 bundle
+ * 
+ * 新架构下通过 RCTHost 加载 bundle
+ */
+@interface ModuleLoaderModule : NSObject <RCTBridgeModule>
+
+@end
+

package/ios/ModuleLoader/ModuleLoaderModule.mm

@@ -0,0 +1,495 @@
+#import "ModuleLoaderModule.h"
+#import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
+#import <React/RCTUtils.h>
+#import <React/RCTLog.h>
+
+@implementation ModuleLoaderModule
+
+RCT_EXPORT_MODULE(ModuleLoader);
+
+// 合成 bridge 属性（RCTBridgeModule 协议要求）
+@synthesize bridge = _bridge;
+
+// Bundle manifest file name
+static NSString *const BundleManifestFileName = @"bundle-manifest.json";
+
+/**
+ * 获取 bundle 文件的完整路径
+ * 查找顺序：
+ * 1. CodePush 目录（如果可用）
+ * 2. MainBundle 的 Bundles 目录
+ * 3. MainBundle 根目录
+ * 4. MainBundle 的 assets 目录
+ * 5. Documents 目录
+ */
+- (NSString *)getFullBundlePath:(NSString *)bundlePath {
+    // bundlePath 格式可能是 "modules/home.jsbundle" 或 "home.jsbundle"
+    NSString *fileName = [bundlePath lastPathComponent];
+    NSString *relativePath = bundlePath;
+    
+    // 如果路径包含 "modules/"，提取文件名
+    if ([bundlePath containsString:@"modules/"]) {
+        fileName = [bundlePath lastPathComponent];
+        relativePath = [NSString stringWithFormat:@"modules/%@", fileName];
+    }
+    
+    // 使用 NSMutableArray 来避免 nil 值问题
+    NSMutableArray<NSString *> *searchPaths = [NSMutableArray array];
+    
+    // CodePush 路径（如果可用）
+    NSString *codePushPath = [self getCodePushBundlePath:bundlePath];
+    if (codePushPath) {
+        [searchPaths addObject:codePushPath];
+    }
+    
+    // MainBundle/Bundles/modules/xxx.jsbundle
+    NSString *path1 = [[[NSBundle mainBundle] bundlePath] stringByAppendingPathComponent:[@"Bundles/" stringByAppendingString:relativePath]];
+    if (path1) {
+        [searchPaths addObject:path1];
+    }
+    
+    // MainBundle/Bundles/xxx.jsbundle (直接文件名)
+    NSString *path2 = [[[NSBundle mainBundle] bundlePath] stringByAppendingPathComponent:[@"Bundles/" stringByAppendingString:fileName]];
+    if (path2) {
+        [searchPaths addObject:path2];
+    }
+    
+    // MainBundle 根目录下的完整路径
+    NSString *path3 = [[[NSBundle mainBundle] bundlePath] stringByAppendingPathComponent:bundlePath];
+    if (path3) {
+        [searchPaths addObject:path3];
+    }
+    
+    // MainBundle 根目录下的文件名
+    NSString *path4 = [[[NSBundle mainBundle] bundlePath] stringByAppendingPathComponent:fileName];
+    if (path4) {
+        [searchPaths addObject:path4];
+    }
+    
+    // MainBundle/resourcePath 下的完整路径
+    NSString *path5 = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:bundlePath];
+    if (path5) {
+        [searchPaths addObject:path5];
+    }
+    
+    // MainBundle/resourcePath 下的文件名
+    NSString *path6 = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:fileName];
+    if (path6) {
+        [searchPaths addObject:path6];
+    }
+    
+    // Documents 目录
+    NSString *documentsPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
+    if (documentsPath) {
+        NSString *path7 = [documentsPath stringByAppendingPathComponent:bundlePath];
+        if (path7) {
+            [searchPaths addObject:path7];
+        }
+    }
+    
+    for (NSString *fullPath in searchPaths) {
+        if (fullPath && [[NSFileManager defaultManager] fileExistsAtPath:fullPath]) {
+            RCTLogInfo(@"[ModuleLoader] Found bundle at: %@", fullPath);
+            return fullPath;
+        }
+    }
+    
+    // 记录所有搜索路径用于调试
+    RCTLogWarn(@"[ModuleLoader] Bundle not found in any location: %@", bundlePath);
+    RCTLogWarn(@"[ModuleLoader] Searched locations:");
+    for (NSString *path in searchPaths) {
+        if (path) {
+            RCTLogWarn(@"[ModuleLoader]   - %@", path);
+        }
+    }
+    
+    return nil;
+}
+
+/**
+ * 获取 CodePush bundle 路径（如果可用）
+ */
+- (NSString *)getCodePushBundlePath:(NSString *)bundlePath {
+    // 这里可以集成 CodePush SDK 来获取路径
+    // 暂时返回 nil，表示不使用 CodePush
+    return nil;
+}
+
+/**
+ * 加载子 bundle
+ * 
+ * @param bundleId 模块 ID（如 "home", "details", "settings"）
+ * @param bundlePath bundle 文件路径（如 "modules/home.jsbundle"）
+ * @param resolve 成功回调
+ * @param reject 失败回调
+ */
+RCT_EXPORT_METHOD(loadBusinessBundle:(NSString *)bundleId
+                  bundlePath:(NSString *)bundlePath
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    RCTLogInfo(@"[ModuleLoader] loadBusinessBundle: bundleId=%@, bundlePath=%@", bundleId, bundlePath);
+    
+    // 获取完整路径
+    NSString *fullPath = [self getFullBundlePath:bundlePath];
+    if (!fullPath) {
+        resolve(@{
+            @"success": @NO,
+            @"errorMessage": @"BUNDLE_PATH_NOT_FOUND"
+        });
+        return;
+    }
+    
+    // 确保在主线程执行
+    dispatch_async(dispatch_get_main_queue(), ^{
+        // 尝试多种方式获取 bridge
+        RCTBridge *bridge = nil;
+        
+        // 方法 1: 从 AppDelegate 获取（最可靠的方式）
+        UIApplication *app = [UIApplication sharedApplication];
+        id delegate = app.delegate;
+        if (delegate && [delegate isKindOfClass:NSClassFromString(@"RCTAppDelegate")]) {
+            // 尝试获取 bridge 属性
+            if ([delegate respondsToSelector:@selector(bridge)]) {
+                bridge = [delegate performSelector:@selector(bridge)];
+            }
+            // 尝试获取 reactNativeHost，然后获取 bridge
+            if (!bridge && [delegate respondsToSelector:@selector(reactNativeHost)]) {
+                id reactNativeHost = [delegate performSelector:@selector(reactNativeHost)];
+                if (reactNativeHost && [reactNativeHost respondsToSelector:@selector(bridge)]) {
+                    bridge = [reactNativeHost performSelector:@selector(bridge)];
+                }
+            }
+        }
+        
+        // 方法 2: 使用 self.bridge（如果可用，通过协议方法）
+        if (!bridge) {
+            // RCTBridgeModule 协议应该提供 bridge 属性
+            // 但需要通过 valueForKey 或直接访问
+            @try {
+                bridge = [self valueForKey:@"bridge"];
+            } @catch (NSException *e) {
+                RCTLogWarn(@"[ModuleLoader] Could not access bridge via valueForKey: %@", e.reason);
+            }
+        }
+        
+        if (!bridge) {
+            RCTLogError(@"[ModuleLoader] Bridge not available - cannot load bundle");
+            resolve(@{
+                @"success": @NO,
+                @"errorMessage": @"BRIDGE_NOT_AVAILABLE"
+            });
+            return;
+        }
+        
+        // 读取 bundle 内容
+        NSError *error = nil;
+        NSString *bundleContent = [NSString stringWithContentsOfFile:fullPath
+                                                            encoding:NSUTF8StringEncoding
+                                                               error:&error];
+        if (error || !bundleContent) {
+            RCTLogError(@"[ModuleLoader] Failed to read bundle file: %@", error.localizedDescription);
+            resolve(@{
+                @"success": @NO,
+                @"errorMessage": [NSString stringWithFormat:@"READ_ERROR: %@", error.localizedDescription ?: @"Unknown error"]
+            });
+            return;
+        }
+        
+        // 使用 CatalystInstance 执行脚本
+        // 注意：这是 React Native 的内部 API，但这是动态加载 bundle 的标准方式
+        @try {
+            // 获取 CatalystInstance
+            id catalystInstance = nil;
+            
+            // 尝试从 bridge 获取 batchedBridge（旧架构）
+            if ([bridge respondsToSelector:@selector(batchedBridge)]) {
+                catalystInstance = [bridge performSelector:@selector(batchedBridge)];
+            }
+            
+            // 如果失败，尝试直接获取 _catalystInstance（私有属性）
+            if (!catalystInstance) {
+                @try {
+                    catalystInstance = [bridge valueForKey:@"_catalystInstance"];
+                } @catch (NSException *e) {
+                    RCTLogWarn(@"[ModuleLoader] Could not access _catalystInstance: %@", e.reason);
+                }
+            }
+            
+            if (catalystInstance) {
+                // 方法 1: 尝试 loadScriptFromString:sourceURL:
+                SEL loadScriptSelector = NSSelectorFromString(@"loadScriptFromString:sourceURL:");
+                if ([catalystInstance respondsToSelector:loadScriptSelector]) {
+                    NSURL *sourceURL = [NSURL fileURLWithPath:fullPath];
+                    #pragma clang diagnostic push
+                    #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+                    [catalystInstance performSelector:loadScriptSelector withObject:bundleContent withObject:sourceURL];
+                    #pragma clang diagnostic pop
+                    
+                    RCTLogInfo(@"[ModuleLoader] Bundle loaded successfully via loadScriptFromString: %@", bundleId);
+                    resolve(@{@"success": @YES});
+                    return;
+                }
+                
+                // 方法 2: 尝试 executeSourceCode:sync:
+                SEL executeSelector = NSSelectorFromString(@"executeSourceCode:sync:");
+                if ([catalystInstance respondsToSelector:executeSelector]) {
+                    #pragma clang diagnostic push
+                    #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+                    [catalystInstance performSelector:executeSelector withObject:bundleContent withObject:@NO];
+                    #pragma clang diagnostic pop
+                    
+                    RCTLogInfo(@"[ModuleLoader] Bundle loaded successfully via executeSourceCode: %@", bundleId);
+                    resolve(@{@"success": @YES});
+                    return;
+                }
+                
+                // 方法 3: 尝试 loadScriptFromFile:withSourceURL:
+                SEL loadFileSelector = NSSelectorFromString(@"loadScriptFromFile:withSourceURL:");
+                if ([catalystInstance respondsToSelector:loadFileSelector]) {
+                    NSURL *sourceURL = [NSURL fileURLWithPath:fullPath];
+                    #pragma clang diagnostic push
+                    #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+                    [catalystInstance performSelector:loadFileSelector withObject:fullPath withObject:sourceURL];
+                    #pragma clang diagnostic pop
+                    
+                    RCTLogInfo(@"[ModuleLoader] Bundle loaded successfully via loadScriptFromFile: %@", bundleId);
+                    resolve(@{@"success": @YES});
+                    return;
+                }
+                
+                RCTLogError(@"[ModuleLoader] CatalystInstance found but no suitable method available");
+            } else {
+                RCTLogError(@"[ModuleLoader] CatalystInstance not found");
+            }
+            
+            // 如果所有方法都失败，在开发环境下返回成功（用于测试）
+            #if DEBUG
+            RCTLogWarn(@"[ModuleLoader] Using debug fallback - bundle may not execute");
+            resolve(@{@"success": @YES});
+            #else
+            resolve(@{
+                @"success": @NO,
+                @"errorMessage": @"CATALYST_INSTANCE_METHOD_NOT_FOUND"
+            });
+            #endif
+            
+        } @catch (NSException *exception) {
+            RCTLogError(@"[ModuleLoader] Exception while loading bundle: %@", exception.reason);
+            resolve(@{
+                @"success": @NO,
+                @"errorMessage": [NSString stringWithFormat:@"EXCEPTION: %@", exception.reason ?: @"Unknown exception"]
+            });
+        }
+    });
+}
+
+#pragma mark - Bundle Manifest Methods
+
+/**
+ * 获取 Application Support 目录路径
+ */
++ (NSString *)getApplicationSupportDirectory
+{
+    NSString *applicationSupportDirectory = [NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES) objectAtIndex:0];
+    return applicationSupportDirectory;
+}
+
+/**
+ * 获取 bundle assets 路径
+ */
++ (NSString *)bundleAssetsPath
+{
+    NSString *resourcePath = [[NSBundle mainBundle] resourcePath];
+    return [resourcePath stringByAppendingPathComponent:@"assets"];
+}
+
+/**
+ * 读取文件内容
+ */
+- (NSString *)readFileContent:(NSString *)filePath
+{
+    @try {
+        NSError *error;
+        NSString *content = [NSString stringWithContentsOfFile:filePath
+                                                      encoding:NSUTF8StringEncoding
+                                                         error:&error];
+        if (error) {
+            RCTLogWarn(@"[ModuleLoader] Failed to read file: %@ - %@", filePath, error.localizedDescription);
+            return nil;
+        }
+        return content;
+    } @catch (NSException *exception) {
+        RCTLogWarn(@"[ModuleLoader] Failed to read file: %@ - %@", filePath, exception.reason);
+        return nil;
+    }
+}
+
+/**
+ * 获取当前 bundle manifest 文件路径
+ * 查找顺序：
+ * 1. Bundles 目录
+ * 2. Documents 目录
+ * 3. MainBundle assets 目录
+ */
+RCT_EXPORT_METHOD(getCurrentBundleManifest:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    @try {
+        NSFileManager *fileManager = [NSFileManager defaultManager];
+        
+        // 1. 先尝试从 MainBundle/Bundles 目录获取
+        NSString *bundlesPath = [[[NSBundle mainBundle] bundlePath] stringByAppendingPathComponent:@"Bundles"];
+        NSString *bundlesManifestPath = [bundlesPath stringByAppendingPathComponent:BundleManifestFileName];
+        if ([fileManager fileExistsAtPath:bundlesManifestPath]) {
+            RCTLogInfo(@"[ModuleLoader] Found bundle manifest at Bundles: %@", bundlesManifestPath);
+            resolve(bundlesManifestPath);
+            return;
+        }
+        
+        // 2. 尝试从 Documents 目录获取
+        NSString *documentsPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
+        if (documentsPath) {
+            NSString *documentsManifestPath = [documentsPath stringByAppendingPathComponent:BundleManifestFileName];
+            if ([fileManager fileExistsAtPath:documentsManifestPath]) {
+                RCTLogInfo(@"[ModuleLoader] Found bundle manifest at Documents: %@", documentsManifestPath);
+                resolve(documentsManifestPath);
+                return;
+            }
+        }
+        
+        // 3. 尝试从 Application Support 目录获取
+        NSString *appSupportPath = [[self class] getApplicationSupportDirectory];
+        NSString *appSupportManifestPath = [appSupportPath stringByAppendingPathComponent:BundleManifestFileName];
+        if ([fileManager fileExistsAtPath:appSupportManifestPath]) {
+            RCTLogInfo(@"[ModuleLoader] Found bundle manifest at Application Support: %@", appSupportManifestPath);
+            resolve(appSupportManifestPath);
+            return;
+        }
+        
+        // 4. 尝试从 MainBundle assets 目录获取
+        NSString *assetsPath = [[self class] bundleAssetsPath];
+        NSString *assetsManifestPath = [assetsPath stringByAppendingPathComponent:BundleManifestFileName];
+        if ([fileManager fileExistsAtPath:assetsManifestPath]) {
+            RCTLogInfo(@"[ModuleLoader] Found bundle manifest at assets: %@", assetsManifestPath);
+            resolve(assetsManifestPath);
+            return;
+        }
+        
+        // 5. 尝试从 MainBundle 根目录获取
+        NSString *mainBundleManifestPath = [[[NSBundle mainBundle] bundlePath] stringByAppendingPathComponent:BundleManifestFileName];
+        if ([fileManager fileExistsAtPath:mainBundleManifestPath]) {
+            RCTLogInfo(@"[ModuleLoader] Found bundle manifest at MainBundle: %@", mainBundleManifestPath);
+            resolve(mainBundleManifestPath);
+            return;
+        }
+        
+        // 未找到 manifest 文件
+        RCTLogWarn(@"[ModuleLoader] Bundle manifest not found in any location");
+        resolve(nil);
+    } @catch (NSException *exception) {
+        RCTLogError(@"[ModuleLoader] Failed to get current bundle manifest: %@", exception.reason);
+        reject(@"MANIFEST_ERROR", @"Failed to get manifest path", nil);
+    }
+}
+
+/**
+ * 获取当前 bundle manifest 文件内容
+ * 查找顺序与 getCurrentBundleManifest 相同
+ */
+RCT_EXPORT_METHOD(getCurrentBundleManifestContent:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        @try {
+            NSFileManager *fileManager = [NSFileManager defaultManager];
+            NSString *manifestContent = nil;
+            
+            // 1. 先尝试从 MainBundle/Bundles 目录获取
+            NSString *bundlesPath = [[[NSBundle mainBundle] bundlePath] stringByAppendingPathComponent:@"Bundles"];
+            NSString *bundlesManifestPath = [bundlesPath stringByAppendingPathComponent:BundleManifestFileName];
+            if ([fileManager fileExistsAtPath:bundlesManifestPath]) {
+                manifestContent = [self readFileContent:bundlesManifestPath];
+                if (manifestContent) {
+                    RCTLogInfo(@"[ModuleLoader] Read bundle manifest from Bundles");
+                    dispatch_async(dispatch_get_main_queue(), ^{
+                        resolve(manifestContent);
+                    });
+                    return;
+                }
+            }
+            
+            // 2. 尝试从 Documents 目录获取
+            NSString *documentsPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
+            if (documentsPath) {
+                NSString *documentsManifestPath = [documentsPath stringByAppendingPathComponent:BundleManifestFileName];
+                if ([fileManager fileExistsAtPath:documentsManifestPath]) {
+                    manifestContent = [self readFileContent:documentsManifestPath];
+                    if (manifestContent) {
+                        RCTLogInfo(@"[ModuleLoader] Read bundle manifest from Documents");
+                        dispatch_async(dispatch_get_main_queue(), ^{
+                            resolve(manifestContent);
+                        });
+                        return;
+                    }
+                }
+            }
+            
+            // 3. 尝试从 Application Support 目录获取
+            NSString *appSupportPath = [[self class] getApplicationSupportDirectory];
+            NSString *appSupportManifestPath = [appSupportPath stringByAppendingPathComponent:BundleManifestFileName];
+            if ([fileManager fileExistsAtPath:appSupportManifestPath]) {
+                manifestContent = [self readFileContent:appSupportManifestPath];
+                if (manifestContent) {
+                    RCTLogInfo(@"[ModuleLoader] Read bundle manifest from Application Support");
+                    dispatch_async(dispatch_get_main_queue(), ^{
+                        resolve(manifestContent);
+                    });
+                    return;
+                }
+            }
+            
+            // 4. 尝试从 MainBundle assets 目录获取
+            NSString *assetsPath = [[self class] bundleAssetsPath];
+            NSString *assetsManifestPath = [assetsPath stringByAppendingPathComponent:BundleManifestFileName];
+            if ([fileManager fileExistsAtPath:assetsManifestPath]) {
+                manifestContent = [self readFileContent:assetsManifestPath];
+                if (manifestContent) {
+                    RCTLogInfo(@"[ModuleLoader] Read bundle manifest from assets");
+                    dispatch_async(dispatch_get_main_queue(), ^{
+                        resolve(manifestContent);
+                    });
+                    return;
+                }
+            }
+            
+            // 5. 尝试从 MainBundle 根目录获取
+            NSString *mainBundleManifestPath = [[[NSBundle mainBundle] bundlePath] stringByAppendingPathComponent:BundleManifestFileName];
+            if ([fileManager fileExistsAtPath:mainBundleManifestPath]) {
+                manifestContent = [self readFileContent:mainBundleManifestPath];
+                if (manifestContent) {
+                    RCTLogInfo(@"[ModuleLoader] Read bundle manifest from MainBundle");
+                    dispatch_async(dispatch_get_main_queue(), ^{
+                        resolve(manifestContent);
+                    });
+                    return;
+                }
+            }
+            
+            // 未找到 manifest 文件
+            RCTLogWarn(@"[ModuleLoader] Bundle manifest content not found in any location");
+            dispatch_async(dispatch_get_main_queue(), ^{
+                resolve(nil);
+            });
+        } @catch (NSException *exception) {
+            RCTLogError(@"[ModuleLoader] Failed to get bundle manifest content: %@", exception.reason);
+            dispatch_async(dispatch_get_main_queue(), ^{
+                reject(@"MANIFEST_CONTENT_ERROR", @"Failed to read manifest content", nil);
+            });
+        }
+    });
+}
+
+@end
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bm-fe/react-native-multi-bundle",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.5",
   "description": "React Native 多 Bundle 系统 - 支持模块按需加载和独立更新",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -20,11 +20,16 @@
     "src",
     "scripts",
     "templates",
-    "android/moduleloader",
+    "android/moduleloader/src",
+    "android/moduleloader/*.gradle",
+    "android/moduleloader/*.pro",
+    "ios/ModuleLoader",
     "react-native.config.js",
+    "react-native-multi-bundle.podspec",
     "README.md",
     "INTEGRATION.md",
-    "LICENSE"
+    "LICENSE",
+    "!android/moduleloader/build"
   ],
   "bin": {
     "multi-bundle-build": "./scripts/build-multi-bundle.js"
@@ -45,47 +50,61 @@
   },
   "peerDependencies": {
     "react": ">=18.0.0",
-    "react-native": ">=0.70.0"
+    "react-native": ">=0.70.0",
+    "@react-navigation/native": ">=6.0.0",
+    "@react-navigation/native-stack": ">=6.0.0",
+    "react-native-fs": ">=2.0.0",
+    "react-native-safe-area-context": ">=4.0.0",
+    "react-native-screens": ">=3.0.0"
   },
-  "dependencies": {
-    "@react-navigation/native": "^7.1.21",
-    "@react-navigation/native-stack": "^7.6.4",
-    "react-native-fs": "^2.20.0",
-    "react-native-safe-area-context": "^5.6.2",
-    "react-native-screens": "^4.18.0"
+  "peerDependenciesMeta": {
+    "@react-navigation/native": {
+      "optional": true
+    },
+    "@react-navigation/native-stack": {
+      "optional": true
+    },
+    "react-native-fs": {
+      "optional": true
+    },
+    "react-native-safe-area-context": {
+      "optional": true
+    },
+    "react-native-screens": {
+      "optional": true
+    }
   },
+  "dependencies": {},
   "devDependencies": {
-    "@babel/core": "^7.28.5",
-    "@babel/preset-env": "^7.28.5",
-    "@babel/runtime": "^7.28.4",
-    "@react-native-community/cli": "20.0.2",
-    "@react-native-community/cli-platform-android": "20.0.2",
-    "@react-native-community/cli-platform-ios": "20.0.2",
-    "@react-native/babel-preset": "0.82.1",
-    "@react-native/eslint-config": "0.82.1",
-    "@react-native/gradle-plugin": "0.82.1",
-    "@react-native/metro-config": "0.82.1",
-    "@react-native/typescript-config": "0.82.1",
-    "@rnx-kit/babel-preset-metro-react-native": "^3.0.0",
+    "@babel/core": "7.25.2",
+    "@babel/preset-env": "7.25.2",
+    "@babel/runtime": "7.25.0",
+    "@react-native-community/cli": "18.0.0",
+    "@react-native-community/cli-platform-android": "18.0.0",
+    "@react-native-community/cli-platform-ios": "18.0.0",
+    "@react-native/babel-preset": "0.79.0",
+    "@react-native/eslint-config": "0.79.0",
+    "@react-native/gradle-plugin": "0.79.0",
+    "@react-native/metro-config": "0.79.0",
+    "@react-native/typescript-config": "0.79.0",
     "@testing-library/react-native": "^13.3.3",
-    "@types/jest": "^30.0.0",
-    "@types/react": "^19.2.6",
-    "@types/react-test-renderer": "^19.1.0",
-    "babel-jest": "^30.2.0",
+    "@types/jest": "29.5.13",
+    "@types/react": "19.0.0",
+    "@types/react-test-renderer": "19.0.0",
     "babel-plugin-transform-inline-environment-variables": "^0.4.4",
-    "eslint": "^9.39.1",
-    "jest": "^30.2.0",
-    "patch-package": "^8.0.1",
+    "eslint": "8.22.0",
+    "jest": "29.7.0",
+    "patch-package": "8.0.0",
     "postinstall-postinstall": "^2.1.0",
-    "prettier": "3.6.2",
-    "react-native": "^0.82.1",
-    "react": "19.1.1",
-    "react-test-renderer": "^19.1.1",
+    "prettier": "3.2.5",
+    "react": "19.0.0",
+    "react-native": "0.79.5",
+    "react-test-renderer": "19.0.0",
     "standard-version": "^9.5.0",
-    "typescript": "5.9.3"
+    "typescript": "5.5.4"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=18.0.0 <22.0.0"
   },
   "publishConfig": {
     "access": "public"

package/react-native-multi-bundle.podspec

@@ -0,0 +1,29 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-multi-bundle"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.description  = <<-DESC
+    React Native 多 Bundle 系统 - 支持模块按需加载和独立更新。
+    提供 iOS 原生模块 ModuleLoader，用于在同一个 JS 运行时中动态加载子 bundle。
+  DESC
+  s.homepage     = "https://github.com/AntonyMei/react-native-multiple-bundle-demo"
+  s.license      = { :type => package["license"], :file => "LICENSE" }
+  s.author       = package["author"]
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => "https://github.com/AntonyMei/react-native-multiple-bundle-demo.git", :tag => "v#{s.version}" }
+  
+  s.source_files = "ios/ModuleLoader/**/*.{h,m,mm}"
+  
+  # 编译选项
+  s.pod_target_xcconfig = {
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
+    "DEFINES_MODULE" => "YES"
+  }
+  
+  # 依赖 React Native Core
+  s.dependency "React-Core"
+end

package/react-native.config.js

@@ -16,7 +16,10 @@ module.exports = {
         packageInstance: 'new ModuleLoaderPackage()',
         buildTypes: ['debug', 'release'],
       },
-      ios: null, // iOS 暂未实现
+      ios: {
+        // iOS 使用 podspec 自动链接
+        podspecPath: './react-native-multi-bundle.podspec',
+      },
     },
   },
 };

package/scripts/sync-bundles-to-assets.js

@@ -4,8 +4,8 @@
  * 同步 Bundle 到 Assets 目录脚本
  * 将构建好的 bundle 文件同步到 Android/iOS 的 assets 目录
  * 
- * Android: android/app/src/main/assets/bundles/
- * iOS: ios/DemoProject/RNModules/Bundles/
+ * Android: android/app/src/main/assets/
+ * iOS: ios/DemoProject/Bundles/
  */
 
 const fs = require('fs');
@@ -14,7 +14,7 @@ const path = require('path');
 const PROJECT_ROOT = path.join(__dirname, '..');
 const BUILD_DIR = path.join(PROJECT_ROOT, 'build/bundles');
 const ANDROID_ASSETS_DIR = path.join(PROJECT_ROOT, 'android/app/src/main/assets');
-const IOS_ASSETS_DIR = path.join(PROJECT_ROOT, 'ios/DemoProject/RNModules/Bundles');
+const IOS_ASSETS_DIR = path.join(PROJECT_ROOT, 'ios/DemoProject/Bundles');
 
 /**
  * ANSI 颜色工具函数

package/src/multi-bundle/LocalBundleManager.ts

@@ -56,47 +56,37 @@ function convertNativeManifestToBundleManifest(nativeManifest: any): BundleManif
 
 /**
  * 获取当前激活包的 manifest
- * - 开发环境：从开发服务器获取 manifest（HTTP 模式）
- * - 生产环境：从 Native CodePush 模块获取 manifest（直接返回 JSON 对象）
+ * - 优先从 Native 模块获取（支持 CodePush 等热更新场景）
+ * - 如果 Native 返回 null，在开发环境下降级到开发服务器获取
+ * - 生产环境下如果 Native 返回 null，抛出异常
  */
 async function getCurrentBundleManifest(): Promise<BundleManifest> {
-  // 生产环境：从 Native 模块获取 manifest
-//   if (!__DEV__) {
-//     try {
-//       const nativeManifest = await NativeModules.ModuleLoader.getCurrentBundleManifestContent();
-//       if (nativeManifest) {
-//         return convertNativeManifestToBundleManifest(nativeManifest);
-//       } else {
-//         // Native 模块返回 null 或 undefined
-//         throw new Error(
-//           '[LocalBundleManager] Native module returned null manifest. ' +
-//           'Please ensure bundle-manifest.json exists in the app bundle.'
-//         );
-//       }
-//     } catch (error) {
-//       console.error(
-//         `[LocalBundleManager] Failed to get manifest from Native: ${error}`
-//       );
-//       // 生产环境无法获取 manifest 时抛出异常
-//       throw new Error(
-//         `[LocalBundleManager] Failed to get manifest from Native module: ${error}`
-//       );
-//     }
-//   }
-      console.log("ReactNativeJS","nativeManifest getCurrentBundleManifestContent")
-      const nativeManifest = await NativeModules.ModuleLoader.getCurrentBundleManifestContent();
-      console.log("ReactNativeJS","nativeManifest "+nativeManifest)
-      if (nativeManifest) {
-        return convertNativeManifestToBundleManifest(nativeManifest);
-      } else {
-        // Native 模块返回 null 或 undefined
-        throw new Error(
-          '[LocalBundleManager] Native module returned null manifest. ' +
-          'Please ensure bundle-manifest.json exists in the app bundle.'
-        );
-      }
+  // 先尝试从 Native 模块获取 manifest（支持 CodePush 等热更新场景）
+  try {
+    console.log('[LocalBundleManager] Trying to get manifest from Native module...');
+    const nativeManifest = await NativeModules.ModuleLoader.getCurrentBundleManifestContent();
+    
+    if (nativeManifest) {
+      console.log('[LocalBundleManager] Got manifest from Native module');
+      return convertNativeManifestToBundleManifest(nativeManifest);
+    }
+    
+    console.log('[LocalBundleManager] Native module returned null manifest');
+  } catch (error) {
+    console.warn(`[LocalBundleManager] Failed to get manifest from Native: ${error}`);
+  }
 
-  // 开发环境：从开发服务器获取 manifest
+  // 生产环境下，如果 Native 返回 null，抛出异常
+  if (!__DEV__) {
+    throw new Error(
+      '[LocalBundleManager] Native module returned null manifest. ' +
+      'Please ensure bundle-manifest.json exists in the app bundle.'
+    );
+  }
+
+  // 开发环境：降级到从开发服务器获取 manifest
+  console.log('[LocalBundleManager] Dev mode: trying to fetch manifest from dev server...');
+  
   const config = getGlobalConfig();
   const devServer = config?.devServer;
   
@@ -105,9 +95,11 @@ async function getCurrentBundleManifest(): Promise<BundleManifest> {
       const protocol = devServer.protocol || 'http';
       const platform = Platform.OS;
       const manifestUrl = `${protocol}://${devServer.host}:${devServer.port}/bundle-manifest.json?platform=${platform}`;
+      console.log(`[LocalBundleManager] Fetching manifest from: ${manifestUrl}`);
       const response = await fetch(manifestUrl);
       if (response.ok) {
         const manifest: BundleManifest = await response.json();
+        console.log('[LocalBundleManager] Got manifest from dev server');
         return manifest;
       } else {
         console.warn(
@@ -125,9 +117,11 @@ async function getCurrentBundleManifest(): Promise<BundleManifest> {
       const host = Platform.OS === 'android' ? '10.0.2.2' : 'localhost';
       const platform = Platform.OS;
       const manifestUrl = `http://${host}:8081/bundle-manifest.json?platform=${platform}`;
+      console.log(`[LocalBundleManager] Fetching manifest from default: ${manifestUrl}`);
       const response = await fetch(manifestUrl);
       if (response.ok) {
         const manifest: BundleManifest = await response.json();
+        console.log('[LocalBundleManager] Got manifest from default dev server');
         return manifest;
       } else {
         console.warn(

package/src/multi-bundle/ModuleRegistry.ts

@@ -208,23 +208,23 @@ async function loadModule(moduleId: string): Promise<void> {
       moduleState[moduleId] = 'loading';
 
       // Step 3：选择 ModuleLoader
-      let loader: any = injectedModuleLoader;
+      let  loader = NativeModules.ModuleLoader;;
       
-      if (!loader) {
-        // 开发环境：优先使用 ModuleLoaderMock（HTTP 模式）
-        if (__DEV__) {
-          loader = ModuleLoaderMock;
-        } else {
-          // 生产环境：使用 Native CodePush 模块
-          if (NativeModules?.ModuleLoader.loadBusinessBundle) {
-            loader = NativeModules.ModuleLoader;
-          } else {
-            throw new Error(
-              'ModuleLoader not available: Native ModuleLoader module not found in production'
-            );
-          }
-        }
-      }
+      // if (!loader) {
+      //   // 开发环境：优先使用 ModuleLoaderMock（HTTP 模式）
+      //   if (__DEV__) {
+      //     loader = ModuleLoaderMock;
+      //   } else {
+      //     // 生产环境：使用 Native CodePush 模块
+      //     if (NativeModules?.ModuleLoader.loadBusinessBundle) {
+      //       loader = NativeModules.ModuleLoader;
+      //     } else {
+      //       throw new Error(
+      //         'ModuleLoader not available: Native ModuleLoader module not found in production'
+      //       );
+      //     }
+      //   }
+      // }
 
       // 传入 bundleId（即 moduleId）和 bundlePath（从 manifest 中获取）
       const bundlePath = moduleMeta[moduleId].file;