@bravemobile/react-native-code-push 12.4.1 → 13.0.0

package/CodePush.podspec

@@ -14,7 +14,7 @@ Pod::Spec.new do |s|
   s.tvos.deployment_target = '15.5'
   s.preserve_paths = '*.js'
   s.library        = 'z'
-  s.source_files = 'ios/CodePush/*.{h,m}'
+  s.source_files = 'ios/CodePush/*.{h,m,mm}'
   s.public_header_files = ['ios/CodePush/CodePush.h']
 
   # Note: Even though there are copy/pasted versions of some of these dependencies in the repo,
@@ -22,4 +22,17 @@ Pod::Spec.new do |s|
   # linked properly at a parent workspace level.
   s.dependency 'React-Core'
   s.dependency 'SSZipArchive', '~> 2.5.5'
+
+  if ENV['RCT_NEW_ARCH_ENABLED'] == '1'
+    s.compiler_flags = '-DRCT_NEW_ARCH_ENABLED=1'
+    s.pod_target_xcconfig = {
+      'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
+      'HEADER_SEARCH_PATHS' => "\"$(PODS_ROOT)/Headers/Public/ReactCodegen\" \"${PODS_CONFIGURATION_BUILD_DIR}/ReactCodegen/ReactCodegen.framework/Headers\""
+    }
+
+    s.dependency 'ReactCodegen'
+    s.dependency 'RCTRequired'
+    s.dependency 'RCTTypeSafety'
+    s.dependency 'ReactCommon/turbomodule/core'
+  end
 end

package/README.md

@@ -13,6 +13,9 @@ Supports React Native 0.77 ~ 0.86.
 > [!NOTE]
 > If you are using React Native 0.76 or lower, please use version `12.0.2` of this library.
 
+> [!IMPORTANT]
+> `13.0.0` migrates the native module to TurboModule. A `13.0.0` binary only runs OTA bundles built with `13.0.0` or later, so ship a new binary version and start its release history fresh when you upgrade.
+
 (Tested on the React Native CLI template apps)
 
 ### ✅ Requirements

package/android/app/build.gradle

@@ -1,10 +1,17 @@
 apply plugin: "com.android.library"
+apply plugin: "com.facebook.react"
 
 def DEFAULT_COMPILE_SDK_VERSION = 26
 def DEFAULT_BUILD_TOOLS_VERSION = "26.0.3"
 def DEFAULT_TARGET_SDK_VERSION = 26
 def DEFAULT_MIN_SDK_VERSION = 16
 
+react {
+    jsRootDir = file("../..")
+    libraryName = "RNCodePushSpec"
+    codegenJavaPackageName = "com.microsoft.codepush.react"
+}
+
 android {
     namespace "com.microsoft.codepush.react"
 

package/android/app/src/main/java/com/microsoft/codepush/react/CodePush.java

@@ -4,18 +4,25 @@ import android.content.Context;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 
-import com.facebook.react.ReactPackage;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.TurboReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.uimanager.ViewManager;
 
 import org.json.JSONException;
 import org.json.JSONObject;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
-public class CodePush implements ReactPackage {
+public class CodePush extends TurboReactPackage {
 
     private static boolean sIsRunningBinaryVersion = false;
     private static boolean sNeedToReportRollback = false;
@@ -300,17 +307,45 @@ public class CodePush implements ReactPackage {
     }
 
     @Override
-    public List<NativeModule> createNativeModules(ReactApplicationContext reactApplicationContext) {
-        CodePushNativeModule codePushModule = new CodePushNativeModule(reactApplicationContext, this, mUpdateManager, mTelemetryManager, mSettingsManager);
-        CodePushDialog dialogModule = new CodePushDialog(reactApplicationContext);
+    public @Nullable NativeModule getModule(String name, ReactApplicationContext reactApplicationContext) {
+        if (!CodePushNativeModule.NAME.equals(name)) {
+            return null;
+        }
+
+        return new CodePushNativeModule(
+                reactApplicationContext,
+                this,
+                mUpdateManager,
+                mTelemetryManager,
+                mSettingsManager
+        );
+    }
 
-        List<NativeModule> nativeModules = new ArrayList<>();
-        nativeModules.add(codePushModule);
-        nativeModules.add(dialogModule);
-        return nativeModules;
+    @Override
+    public ReactModuleInfoProvider getReactModuleInfoProvider() {
+        return new ReactModuleInfoProvider() {
+            @Override
+            public Map<String, ReactModuleInfo> getReactModuleInfos() {
+                Map<String, ReactModuleInfo> reactModuleInfoMap = new HashMap<>();
+                reactModuleInfoMap.put(
+                        CodePushNativeModule.NAME,
+                        new ReactModuleInfo(
+                                CodePushNativeModule.NAME,
+                                CodePushNativeModule.class.getName(),
+                                false,
+                                false,
+                                false,
+                                false,
+                                true
+                        )
+                );
+                return reactModuleInfoMap;
+            }
+        };
     }
+
     @Override
-    public List<ViewManager> createViewManagers(ReactApplicationContext reactApplicationContext) {
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactApplicationContext) {
         return new ArrayList<>();
     }
 }

package/android/app/src/main/java/com/microsoft/codepush/react/CodePushNativeModule.java

@@ -2,7 +2,6 @@ package com.microsoft.codepush.react;
 
 import android.app.Activity;
 import android.content.SharedPreferences;
-import android.os.AsyncTask;
 import android.os.Handler;
 import android.os.Looper;
 import android.view.View;
@@ -20,11 +19,11 @@ import com.facebook.react.bridge.JSBundleLoader;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.annotations.UnstableReactNativeAPI;
+import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.runtime.ReactHostDelegate;
@@ -37,15 +36,19 @@ import java.io.IOException;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
 import java.util.UUID;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+@ReactModule(name = CodePushNativeModule.NAME)
+public class CodePushNativeModule extends NativeCodePushSpec {
+    public static final String NAME = "CodePush";
 
-public class CodePushNativeModule extends ReactContextBaseJavaModule {
     private String mBinaryContentsHash = null;
     private String mClientUniqueId = null;
     private LifecycleEventListener mLifecycleEventListener = null;
     private int mMinimumBackgroundDuration = 0;
+    private final ExecutorService mBackgroundExecutor = Executors.newSingleThreadExecutor();
 
     private CodePush mCodePush;
     private SettingsManager mSettingsManager;
@@ -76,24 +79,15 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     }
 
     @Override
-    public Map<String, Object> getConstants() {
-        final Map<String, Object> constants = new HashMap<>();
-
-        constants.put("codePushInstallModeImmediate", CodePushInstallMode.IMMEDIATE.getValue());
-        constants.put("codePushInstallModeOnNextRestart", CodePushInstallMode.ON_NEXT_RESTART.getValue());
-        constants.put("codePushInstallModeOnNextResume", CodePushInstallMode.ON_NEXT_RESUME.getValue());
-        constants.put("codePushInstallModeOnNextSuspend", CodePushInstallMode.ON_NEXT_SUSPEND.getValue());
-
-        constants.put("codePushUpdateStateRunning", CodePushUpdateState.RUNNING.getValue());
-        constants.put("codePushUpdateStatePending", CodePushUpdateState.PENDING.getValue());
-        constants.put("codePushUpdateStateLatest", CodePushUpdateState.LATEST.getValue());
-
-        return constants;
+    public String getName() {
+        return NAME;
     }
 
     @Override
-    public String getName() {
-        return "CodePush";
+    public void invalidate() {
+        clearLifecycleEventListener();
+        mBackgroundExecutor.shutdownNow();
+        super.invalidate();
     }
 
     private void loadBundleLegacy() {
@@ -265,6 +259,21 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
         return null;
     }
 
+    private void executeInBackground(Runnable runnable) {
+        mBackgroundExecutor.execute(runnable);
+    }
+
+    private void emitDownloadProgressEvent(DownloadProgress downloadProgress) {
+        if (mEventEmitterCallback != null) {
+            emitOnDownloadProgress(downloadProgress.createWritableMap());
+            return;
+        }
+
+        getReactApplicationContext()
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(CodePushConstants.DOWNLOAD_PROGRESS_EVENT_NAME, downloadProgress.createWritableMap());
+    }
+
     private void restartAppInternal(boolean onlyIfUpdateIsPending) {
         if (this._restartInProgress) {
             CodePushUtils.log("Restart request queued until the current restart is completed");
@@ -292,7 +301,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void allow(Promise promise) {
+    public void allow() {
         CodePushUtils.log("Re-allowing restarts");
         this._allowed = true;
 
@@ -302,42 +311,29 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
             this._restartQueue.remove(0);
             this.restartAppInternal(buf);
         }
-
-        promise.resolve(null);
-        return;
     }
 
     @ReactMethod
-    public void clearPendingRestart(Promise promise) {
+    public void clearPendingRestart() {
         this._restartQueue.clear();
-        promise.resolve(null);
-        return;
     }
 
     @ReactMethod
-    public void disallow(Promise promise) {
+    public void disallow() {
         CodePushUtils.log("Disallowing restarts");
         this._allowed = false;
-        promise.resolve(null);
-        return;
     }
 
     @ReactMethod
-    public void restartApp(boolean onlyIfUpdateIsPending, Promise promise) {
-        try {
-            restartAppInternal(onlyIfUpdateIsPending);
-            promise.resolve(null);
-        } catch(CodePushUnknownException e) {
-            CodePushUtils.log(e);
-            promise.reject(e);
-        }
+    public void restartApp(boolean onlyIfUpdateIsPending) {
+        restartAppInternal(onlyIfUpdateIsPending);
     }
 
     @ReactMethod
     public void downloadUpdate(final ReadableMap updatePackage, final boolean notifyProgress, final Promise promise) {
-        AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
+        executeInBackground(new Runnable() {
             @Override
-            protected Void doInBackground(Void... params) {
+            public void run() {
                 try {
                     JSONObject mutableUpdatePackage = CodePushUtils.convertReadableToJsonObject(updatePackage);
                     mUpdateManager.downloadPackage(mutableUpdatePackage, mCodePush.getAssetsBundleFileName(), new DownloadProgressCallback() {
@@ -347,9 +343,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                                 new DownloadProgressEventDispatcher.EventEmitter() {
                                     @Override
                                     public void emit(DownloadProgress downloadProgress) {
-                                        getReactApplicationContext()
-                                                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                                                .emit(CodePushConstants.DOWNLOAD_PROGRESS_EVENT_NAME, downloadProgress.createWritableMap());
+                                        emitDownloadProgressEvent(downloadProgress);
                                     }
                                 });
 
@@ -399,12 +393,8 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
-
-                return null;
             }
-        };
-
-        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+        });
     }
 
     @ReactMethod
@@ -429,16 +419,17 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void getUpdateMetadata(final int updateState, final Promise promise) {
-        AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
+    public void getUpdateMetadata(final double updateStateValue, final Promise promise) {
+        executeInBackground(new Runnable() {
             @Override
-            protected Void doInBackground(Void... params) {
+            public void run() {
                 try {
+                    int updateState = (int) updateStateValue;
                     JSONObject currentPackage = mUpdateManager.getCurrentPackage();
 
                     if (currentPackage == null) {
                         promise.resolve(null);
-                        return null;
+                        return;
                     }
 
                     Boolean currentUpdateIsPending = false;
@@ -459,7 +450,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
 
                         if (previousPackage == null) {
                             promise.resolve(null);
-                            return null;
+                            return;
                         }
 
                         promise.resolve(CodePushUtils.convertJsonObjectToWritable(previousPackage));
@@ -488,19 +479,15 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
-
-                return null;
             }
-        };
-
-        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+        });
     }
 
     @ReactMethod
     public void getNewStatusReport(final Promise promise) {
-        AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
+        executeInBackground(new Runnable() {
             @Override
-            protected Void doInBackground(Void... params) {
+            public void run() {
                 try {
                     if (mCodePush.needToReportRollback()) {
                         mCodePush.setNeedToReportRollback(false);
@@ -512,7 +499,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                                 WritableMap failedStatusReport = mTelemetryManager.getRollbackReport(lastFailedPackage);
                                 if (failedStatusReport != null) {
                                     promise.resolve(failedStatusReport);
-                                    return null;
+                                    return;
                                 }
                             } catch (JSONException e) {
                                 throw new CodePushUnknownException("Unable to read failed updates information stored in SharedPreferences.", e);
@@ -524,41 +511,40 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                             WritableMap newPackageStatusReport = mTelemetryManager.getUpdateReport(CodePushUtils.convertJsonObjectToWritable(currentPackage));
                             if (newPackageStatusReport != null) {
                                 promise.resolve(newPackageStatusReport);
-                                return null;
+                                return;
                             }
                         }
                     } else if (mCodePush.isRunningBinaryVersion()) {
                         WritableMap newAppVersionStatusReport = mTelemetryManager.getBinaryUpdateReport(mCodePush.getAppVersion());
                         if (newAppVersionStatusReport != null) {
                             promise.resolve(newAppVersionStatusReport);
-                            return null;
+                            return;
                         }
                     } else {
                         WritableMap retryStatusReport = mTelemetryManager.getRetryStatusReport();
                         if (retryStatusReport != null) {
                             promise.resolve(retryStatusReport);
-                            return null;
+                            return;
                         }
                     }
 
-                    promise.resolve("");
+                    promise.resolve(null);
                 } catch(CodePushUnknownException e) {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
-                return null;
             }
-        };
-
-        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+        });
     }
 
     @ReactMethod
-    public void installUpdate(final ReadableMap updatePackage, final int installMode, final int minimumBackgroundDuration, final Promise promise) {
-        AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
+    public void installUpdate(final ReadableMap updatePackage, final double installModeValue, final double minimumBackgroundDurationValue, final Promise promise) {
+        executeInBackground(new Runnable() {
             @Override
-            protected Void doInBackground(Void... params) {
+            public void run() {
                 try {
+                    int installMode = (int) installModeValue;
+                    int minimumBackgroundDuration = (int) minimumBackgroundDurationValue;
                     mUpdateManager.installPackage(CodePushUtils.convertReadableToJsonObject(updatePackage), mSettingsManager.isPendingUpdate(null));
 
                     String pendingHash = CodePushUtils.tryGetString(updatePackage, CodePushConstants.PACKAGE_HASH_KEY);
@@ -568,13 +554,12 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                         mSettingsManager.savePendingUpdate(pendingHash, /* isLoading */false);
                     }
 
-                    if (installMode == CodePushInstallMode.ON_NEXT_RESUME.getValue() ||
-                        // We also add the resume listener if the installMode is IMMEDIATE, because
-                        // if the current activity is backgrounded, we want to reload the bundle when
-                        // it comes back into the foreground.
-                        installMode == CodePushInstallMode.IMMEDIATE.getValue() ||
-                        installMode == CodePushInstallMode.ON_NEXT_SUSPEND.getValue()) {
-
+                    if (installMode == CodePushInstallMode.ON_NEXT_RESUME.getValue()
+                            // We also add the resume listener if the installMode is IMMEDIATE, because
+                            // if the current activity is backgrounded, we want to reload the bundle when
+                            // it comes back into the foreground.
+                            || installMode == CodePushInstallMode.IMMEDIATE.getValue()
+                            || installMode == CodePushInstallMode.ON_NEXT_SUSPEND.getValue()) {
                         // Store the minimum duration on the native module as an instance
                         // variable instead of relying on a closure below, so that any
                         // subsequent resume-based installs could override it.
@@ -628,17 +613,13 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                         }
                     }
 
-                    promise.resolve("");
+                    promise.resolve(null);
                 } catch(CodePushUnknownException e) {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
-
-                return null;
             }
-        };
-
-        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+        });
     }
 
     @ReactMethod
@@ -695,7 +676,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     public void notifyApplicationReady(Promise promise) {
         try {
             mSettingsManager.removePendingUpdate();
-            promise.resolve("");
+            promise.resolve(null);
         } catch(CodePushUnknownException e) {
             CodePushUtils.log(e);
             promise.reject(e);

package/cli/dist/functions/runHermesEmitBinaryCommand.js

@@ -4,6 +4,7 @@
 import childProcess from "child_process";
 import fs from "fs";
 import path from "path";
+import { createRequire } from "node:module";
 import shell from "shelljs";
 /**
  * Run Hermes compile CLI command
@@ -12,9 +13,10 @@ import shell from "shelljs";
  * @param outputPath {string} Path to output .hbc file
  * @param sourcemapOutput {string} Path to output sourcemap file (Warning: if sourcemapOutput points to the outputPath, the sourcemap will be included in the CodePush bundle and increase the deployment size)
  * @param extraHermesFlags {string[]} Additional options to pass to `hermesc` command
+ * @param projectRoot {string} Root directory of the target app project used to resolve the app's React Native module and locate the matching Hermes compiler. Defaults to the current working directory.
  * @return {Promise<void>}
  */
-export async function runHermesEmitBinaryCommand(bundleName, outputPath, sourcemapOutput, extraHermesFlags = []) {
+export async function runHermesEmitBinaryCommand(bundleName, outputPath, sourcemapOutput, extraHermesFlags = [], projectRoot = process.cwd()) {
     const hermesArgs = [
         '-emit-binary',
         '-out',
@@ -28,7 +30,7 @@ export async function runHermesEmitBinaryCommand(bundleName, outputPath, sourcem
     console.log('Converting JS bundle to byte code via Hermes, running command:\n');
     return new Promise((resolve, reject) => {
         try {
-            const hermesCommand = getHermesCommand();
+            const hermesCommand = getHermesCommand(projectRoot);
             const disableAllWarningsArg = '-w';
             shell.exec(`${hermesCommand} ${hermesArgs.join(' ')} ${disableAllWarningsArg}`);
             // Copy HBC bundle to overwrite JS bundle
@@ -47,7 +49,7 @@ export async function runHermesEmitBinaryCommand(bundleName, outputPath, sourcem
             return;
         }
         // compose-source-maps.js file path
-        const composeSourceMapsPath = getComposeSourceMapsPath();
+        const composeSourceMapsPath = getComposeSourceMapsPath(projectRoot);
         if (composeSourceMapsPath === null) {
             throw new Error('react-native compose-source-maps.js scripts is not found');
         }
@@ -87,7 +89,7 @@ export async function runHermesEmitBinaryCommand(bundleName, outputPath, sourcem
         });
     });
 }
-function getHermesCommand() {
+function getHermesCommand(projectRoot) {
     const fileExists = (file) => {
         try {
             return fs.statSync(file).isFile();
@@ -96,7 +98,7 @@ function getHermesCommand() {
             return false;
         }
     };
-    const hermescExecutable = path.join(getHermesCompilerPath(), getHermesOSBin(), getHermesOSExe());
+    const hermescExecutable = path.join(getHermesCompilerPath(projectRoot), getHermesOSBin(), getHermesOSExe());
     if (fileExists(hermescExecutable)) {
         return hermescExecutable;
     }
@@ -124,45 +126,67 @@ function getHermesOSExe() {
             return hermesExecutableName;
     }
 }
-function getComposeSourceMapsPath() {
+function getComposeSourceMapsPath(projectRoot) {
     // detect if compose-source-maps.js script exists
-    const composeSourceMaps = path.join(getReactNativePackagePath(), 'scripts', 'compose-source-maps.js');
+    const composeSourceMaps = path.join(getReactNativePackagePath(projectRoot), 'scripts', 'compose-source-maps.js');
     if (fs.existsSync(composeSourceMaps)) {
         return composeSourceMaps;
     }
     return null;
 }
-function getReactNativePackagePath() {
-    const result = childProcess.spawnSync('node', [
-        '--print',
-        "require.resolve('react-native/package.json')",
-    ]);
-    const packagePath = path.dirname(result.stdout.toString());
-    if (result.status === 0 && directoryExistsSync(packagePath)) {
+function getReactNativePackagePath(projectRoot) {
+    const packagePath = resolvePackageRoot(projectRoot, 'react-native');
+    if (packagePath !== null) {
         return packagePath;
     }
-    return path.join('node_modules', 'react-native');
+    return path.join(projectRoot, 'node_modules', 'react-native');
 }
-function getHermescDirPathInHermesCompilerPackage() {
-    const result = childProcess.spawnSync('node', [
-        '--print',
-        "require.resolve('hermes-compiler/package.json')",
-    ]);
-    const packagePath = path.dirname(result.stdout.toString());
-    const hermescDirPath = path.join(packagePath, 'hermesc');
-    if (result.status === 0 && directoryExistsSync(hermescDirPath)) {
+function getHermescDirPathInHermesCompilerPackage(projectRoot) {
+    const reactNativePackagePath = getReactNativePackagePath(projectRoot);
+    const hermescDirPath = path.join(path.dirname(reactNativePackagePath), 'hermes-compiler', 'hermesc');
+    if (directoryExistsSync(hermescDirPath)) {
         return hermescDirPath;
     }
     return null;
 }
-function getHermesCompilerPath() {
-    const hermescDirPath = getHermescDirPathInHermesCompilerPackage();
+function getHermesCompilerPath(projectRoot) {
+    const hermescDirPath = getHermescDirPathInHermesCompilerPackage(projectRoot);
     if (hermescDirPath) {
         // Since react-native 0.83, Hermes compiler executables are in 'hermes-compiler' package
         return hermescDirPath;
     }
     else {
-        return path.join(getReactNativePackagePath(), 'sdks', 'hermesc');
+        return path.join(getReactNativePackagePath(projectRoot), 'sdks', 'hermesc');
+    }
+}
+function resolvePackageRoot(projectRoot, packageName) {
+    try {
+        const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
+        const resolvedPath = projectRequire.resolve(packageName);
+        return findPackageRoot(packageName, resolvedPath);
+    }
+    catch {
+        return null;
+    }
+}
+function findPackageRoot(packageName, resolvedPath) {
+    let currentPath = path.dirname(resolvedPath);
+    while (true) {
+        const packageJsonPath = path.join(currentPath, 'package.json');
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            if (packageJson.name === packageName) {
+                return currentPath;
+            }
+        }
+        catch {
+            // Continue traversing upward until the package root is found.
+        }
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) {
+            return null;
+        }
+        currentPath = parentPath;
     }
 }
 function directoryExistsSync(dirname) {