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

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,474 @@
+#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";
+
+#pragma mark - Bundle Path Resolution
+
+/**
+ * 获取 bundle 文件的完整路径
+ */
+- (NSString *)getFullBundlePath:(NSString *)bundlePath {
+    NSString *fileName = [bundlePath lastPathComponent];
+    NSString *relativePath = bundlePath;
+
+    if ([bundlePath containsString:@"modules/"]) {
+        fileName = [bundlePath lastPathComponent];
+        relativePath = [NSString stringWithFormat:@"modules/%@", fileName];
+    }
+
+    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];
+
+    NSString *path4 = [[[NSBundle mainBundle] bundlePath] stringByAppendingPathComponent:fileName];
+    if (path4) [searchPaths addObject:path4];
+
+    // resourcePath
+    NSString *path5 = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:bundlePath];
+    if (path5) [searchPaths addObject:path5];
+
+    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: %@", bundlePath);
+    for (NSString *path in searchPaths) {
+        if (path) RCTLogWarn(@"[ModuleLoader]   - %@", path);
+    }
+
+    return nil;
+}
+
+- (NSString *)getCodePushBundlePath:(NSString *)bundlePath {
+    return nil;
+}
+
+#pragma mark - Bridge Access
+
+/**
+ * 获取当前的 RCTBridge
+ */
+- (RCTBridge *)getCurrentBridge {
+    // 方法 1: 使用模块自带的 bridge
+    if (self.bridge) {
+        return self.bridge;
+    }
+
+    // 方法 2: 从 AppDelegate 获取
+    UIApplication *app = [UIApplication sharedApplication];
+    id delegate = app.delegate;
+
+    if ([delegate respondsToSelector:@selector(bridge)]) {
+        RCTBridge *bridge = [delegate performSelector:@selector(bridge)];
+        if (bridge) return bridge;
+    }
+
+    // 方法 3: 通过 reactNativeHost
+    if ([delegate respondsToSelector:@selector(reactNativeHost)]) {
+        id reactNativeHost = [delegate performSelector:@selector(reactNativeHost)];
+        if (reactNativeHost && [reactNativeHost respondsToSelector:@selector(bridge)]) {
+            RCTBridge *bridge = [reactNativeHost performSelector:@selector(bridge)];
+            if (bridge) return bridge;
+        }
+    }
+
+    // 方法 4: 通过 rootViewFactory (新架构)
+    if ([delegate respondsToSelector:@selector(rootViewFactory)]) {
+        id factory = [delegate performSelector:@selector(rootViewFactory)];
+        if (factory && [factory respondsToSelector:@selector(bridge)]) {
+            RCTBridge *bridge = [factory performSelector:@selector(bridge)];
+            if (bridge) return bridge;
+        }
+    }
+
+    return nil;
+}
+
+#pragma mark - Bundle Loading Methods
+
+/**
+ * 尝试使用各种方法加载 bundle
+ */
+- (BOOL)tryLoadBundle:(NSString *)bundleContent
+            sourceURL:(NSURL *)sourceURL
+               bridge:(RCTBridge *)bridge
+                error:(NSError **)outError {
+
+    // 获取 batchedBridge（在新旧架构中都可能存在）
+    id targetBridge = bridge;
+    @try {
+        if ([bridge respondsToSelector:@selector(batchedBridge)]) {
+            id batchedBridge = [bridge performSelector:@selector(batchedBridge)];
+            if (batchedBridge) {
+                targetBridge = batchedBridge;
+                RCTLogInfo(@"[ModuleLoader] Using batchedBridge");
+            }
+        }
+    } @catch (NSException *e) {
+        RCTLogWarn(@"[ModuleLoader] Could not get batchedBridge: %@", e.reason);
+    }
+
+    // 方法 1: 尝试 executeSourceCode:withSourceURL:onComplete: (新架构可能支持)
+    SEL executeWithCompleteSel = NSSelectorFromString(@"executeSourceCode:withSourceURL:onComplete:");
+    if ([targetBridge respondsToSelector:executeWithCompleteSel]) {
+        @try {
+            RCTLogInfo(@"[ModuleLoader] Trying executeSourceCode:withSourceURL:onComplete:");
+            NSData *sourceData = [bundleContent dataUsingEncoding:NSUTF8StringEncoding];
+
+            __block BOOL completed = NO;
+            __block NSError *execError = nil;
+
+            void (^onComplete)(NSError *) = ^(NSError *error) {
+                execError = error;
+                completed = YES;
+            };
+
+            NSMethodSignature *sig = [targetBridge methodSignatureForSelector:executeWithCompleteSel];
+            NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:sig];
+            [invocation setTarget:targetBridge];
+            [invocation setSelector:executeWithCompleteSel];
+            [invocation setArgument:&sourceData atIndex:2];
+            [invocation setArgument:&sourceURL atIndex:3];
+            [invocation setArgument:&onComplete atIndex:4];
+            [invocation invoke];
+
+            RCTLogInfo(@"[ModuleLoader] Bundle loaded via executeSourceCode:withSourceURL:onComplete:");
+            return YES;
+        } @catch (NSException *e) {
+            RCTLogWarn(@"[ModuleLoader] executeSourceCode:withSourceURL:onComplete: failed: %@", e.reason);
+        }
+    }
+
+    // 方法 2: 尝试通过 CatalystInstance（旧架构）
+    id catalystInstance = nil;
+    @try {
+        catalystInstance = [targetBridge valueForKey:@"_catalystInstance"];
+    } @catch (NSException *e) {
+        // 继续尝试其他方法
+    }
+
+    if (catalystInstance) {
+        RCTLogInfo(@"[ModuleLoader] Found CatalystInstance, trying legacy methods");
+
+        // 方法 2a: loadScriptFromString:sourceURL:
+        SEL loadScriptSel = NSSelectorFromString(@"loadScriptFromString:sourceURL:");
+        if ([catalystInstance respondsToSelector:loadScriptSel]) {
+            @try {
+                #pragma clang diagnostic push
+                #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+                [catalystInstance performSelector:loadScriptSel withObject:bundleContent withObject:sourceURL];
+                #pragma clang diagnostic pop
+                RCTLogInfo(@"[ModuleLoader] Bundle loaded via loadScriptFromString");
+                return YES;
+            } @catch (NSException *e) {
+                RCTLogWarn(@"[ModuleLoader] loadScriptFromString failed: %@", e.reason);
+            }
+        }
+
+        // 方法 2b: executeSourceCode:sync:
+        SEL executeSel = NSSelectorFromString(@"executeSourceCode:sync:");
+        if ([catalystInstance respondsToSelector:executeSel]) {
+            @try {
+                #pragma clang diagnostic push
+                #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+                [catalystInstance performSelector:executeSel withObject:bundleContent withObject:@NO];
+                #pragma clang diagnostic pop
+                RCTLogInfo(@"[ModuleLoader] Bundle loaded via executeSourceCode:sync:");
+                return YES;
+            } @catch (NSException *e) {
+                RCTLogWarn(@"[ModuleLoader] executeSourceCode:sync: failed: %@", e.reason);
+            }
+        }
+    } else {
+        RCTLogInfo(@"[ModuleLoader] CatalystInstance not available (likely new architecture)");
+    }
+
+    // 方法 3: 尝试使用 RCTCxxBridge 的方法
+    if ([NSStringFromClass([targetBridge class]) containsString:@"Cxx"]) {
+        RCTLogInfo(@"[ModuleLoader] Detected RCTCxxBridge, trying Cxx-specific methods");
+
+        SEL runJSBundleSel = NSSelectorFromString(@"runJSBundle:");
+        if ([targetBridge respondsToSelector:runJSBundleSel]) {
+            @try {
+                #pragma clang diagnostic push
+                #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+                [targetBridge performSelector:runJSBundleSel withObject:sourceURL];
+                #pragma clang diagnostic pop
+                RCTLogInfo(@"[ModuleLoader] Bundle loaded via runJSBundle:");
+                return YES;
+            } @catch (NSException *e) {
+                RCTLogWarn(@"[ModuleLoader] runJSBundle: failed: %@", e.reason);
+            }
+        }
+    }
+
+    // 所有方法都失败
+    if (outError) {
+        *outError = [NSError errorWithDomain:@"ModuleLoader"
+                                        code:1001
+                                    userInfo:@{NSLocalizedDescriptionKey: @"No suitable bundle loading method found"}];
+    }
+
+    return NO;
+}
+
+#pragma mark - Main Load Method
+
+/**
+ * 加载子 bundle
+ */
+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(), ^{
+        RCTBridge *bridge = [self getCurrentBridge];
+
+        if (!bridge) {
+            RCTLogError(@"[ModuleLoader] Bridge not available");
+            resolve(@{@"success": @NO, @"errorMessage": @"BRIDGE_NOT_AVAILABLE"});
+            return;
+        }
+
+        // 读取 bundle 内容
+        NSError *readError = nil;
+        NSString *bundleContent = [NSString stringWithContentsOfFile:fullPath
+                                                            encoding:NSUTF8StringEncoding
+                                                               error:&readError];
+        if (readError || !bundleContent) {
+            RCTLogError(@"[ModuleLoader] Failed to read bundle: %@", readError.localizedDescription);
+            resolve(@{@"success": @NO, @"errorMessage": [NSString stringWithFormat:@"READ_ERROR: %@", readError.localizedDescription ?: @"Unknown"]});
+            return;
+        }
+
+        NSURL *sourceURL = [NSURL fileURLWithPath:fullPath];
+        NSError *loadError = nil;
+
+        BOOL success = [self tryLoadBundle:bundleContent sourceURL:sourceURL bridge:bridge error:&loadError];
+
+        if (success) {
+            RCTLogInfo(@"[ModuleLoader] Bundle loaded successfully: %@", bundleId);
+            resolve(@{@"success": @YES});
+        } else {
+            // 在 DEBUG 模式下返回成功（因为模块可能已经在主 bundle 中）
+            #if DEBUG
+            RCTLogWarn(@"[ModuleLoader] Native loading failed, but continuing (DEBUG mode)");
+            RCTLogWarn(@"[ModuleLoader] Note: In new architecture, dynamic bundle loading has limitations");
+            RCTLogWarn(@"[ModuleLoader] The module may need to be included in the main bundle");
+            resolve(@{@"success": @YES, @"warning": @"NATIVE_LOADING_FAILED_DEBUG_FALLBACK"});
+            #else
+            RCTLogError(@"[ModuleLoader] Failed to load bundle: %@", loadError.localizedDescription);
+            resolve(@{@"success": @NO, @"errorMessage": loadError.localizedDescription ?: @"UNKNOWN_ERROR"});
+            #endif
+        }
+    });
+}
+
+#pragma mark - Bundle Manifest Methods
+
++ (NSString *)getApplicationSupportDirectory {
+    return [NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES) objectAtIndex:0];
+}
+
++ (NSString *)bundleAssetsPath {
+    return [[[NSBundle mainBundle] 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;
+    }
+}
+
+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 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]) {
+                resolve(documentsManifestPath);
+                return;
+            }
+        }
+
+        // 3. Application Support 目录
+        NSString *appSupportPath = [[self class] getApplicationSupportDirectory];
+        NSString *appSupportManifestPath = [appSupportPath stringByAppendingPathComponent:BundleManifestFileName];
+        if ([fileManager fileExistsAtPath:appSupportManifestPath]) {
+            resolve(appSupportManifestPath);
+            return;
+        }
+
+        // 4. MainBundle assets 目录
+        NSString *assetsPath = [[self class] bundleAssetsPath];
+        NSString *assetsManifestPath = [assetsPath stringByAppendingPathComponent:BundleManifestFileName];
+        if ([fileManager fileExistsAtPath:assetsManifestPath]) {
+            resolve(assetsManifestPath);
+            return;
+        }
+
+        // 5. MainBundle 根目录
+        NSString *mainBundleManifestPath = [[[NSBundle mainBundle] bundlePath] stringByAppendingPathComponent:BundleManifestFileName];
+        if ([fileManager fileExistsAtPath:mainBundleManifestPath]) {
+            resolve(mainBundleManifestPath);
+            return;
+        }
+
+        RCTLogWarn(@"[ModuleLoader] Bundle manifest not found");
+        resolve(nil);
+    } @catch (NSException *exception) {
+        RCTLogError(@"[ModuleLoader] Failed to get manifest: %@", exception.reason);
+        reject(@"MANIFEST_ERROR", @"Failed to get manifest path", nil);
+    }
+}
+
+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 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) {
+                        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) {
+                    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) {
+                    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) {
+                    dispatch_async(dispatch_get_main_queue(), ^{ resolve(manifestContent); });
+                    return;
+                }
+            }
+
+            RCTLogWarn(@"[ModuleLoader] Bundle manifest content not found");
+            dispatch_async(dispatch_get_main_queue(), ^{ resolve(nil); });
+        } @catch (NSException *exception) {
+            RCTLogError(@"[ModuleLoader] Failed to get 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.6",
   "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;

package/src/multi-bundle/README.md

@@ -342,3 +342,4 @@ function preloadModule(moduleId: string): Promise<void>
 - [多 Bundle 架构设计](../docs/React%20Native%20多%20bundle%20技术方案.md)
 
 
+