@react-native-oh/react-native-harmony 0.72.82 → 0.77.18

package/metro.config.js

@@ -2,7 +2,7 @@
  * Copyright (c) 2024 Huawei Technologies Co., Ltd.
  *
  * This source code is licensed under the MIT license found in the
- * LICENSE-MIT file in the root directory of this source tree.
+ * LICENSE file in the root directory of this source tree.
  */
 
 //@ts-check
@@ -10,7 +10,8 @@ const pathUtils = require('path');
 const fs = require('fs');
 const colors = require('colors/safe');
 
-let shouldPrintInfoAboutRNRedirection = true;
+const HARMONY_PLATFORM_NAME = 'harmony';
+const RNOH_FALLBACK_PLATFORM_NAME = 'ios';
 
 /**
  * @param msg {string}
@@ -21,12 +22,28 @@ function info(msg) {
 }
 
 /**
- * @param options {{reactNativeHarmonyPackageName: string} | undefined}
+ * @type {string | null}
+ */
+let REQUEST_RESOLUTION_LATEST_PLATFORM = null;
+
+/**
+ * @param options {import("./metro.config").HarmonyMetroConfigOptions}
  * @returns {import("metro-config").InputConfigT}
  */
 function createHarmonyMetroConfig(options) {
-  const reactNativeHarmonyName =
+  /**
+   * The default value needs to be changed to @react-native-oh/react-native-harmony but this is a breaking change.
+   */
+  const reactNativeHarmonyPackageName =
     options?.reactNativeHarmonyPackageName ?? 'react-native-harmony';
+  const reactNativeHarmonyPattern =
+    options?.__reactNativeHarmonyPattern ??
+    pathUtils.sep +
+      reactNativeHarmonyPackageName.replace('/', pathUtils.sep) +
+      pathUtils.sep;
+  const reactNativeInteropLibraryPackagePattern =
+    options?.__reactNativeInteropLibraryPackagePattern;
+
   return {
     transformer: {
       assetRegistryPath: 'react-native/Libraries/Image/AssetRegistry',
@@ -37,45 +54,149 @@ function createHarmonyMetroConfig(options) {
         },
       }),
     },
+    serializer: {
+      getModulesRunBeforeMainModule: () => {
+        if (REQUEST_RESOLUTION_LATEST_PLATFORM !== 'harmony') {
+          return [];
+        }
+        return [require.resolve('./Libraries/Core/InitializeCore')];
+      },
+    },
     resolver: {
-      blockList: [/third-party(\\\\|\\|\/)hermes/],
+      blockList: [/\.cxx/],
       resolveRequest: (ctx, moduleName, platform) => {
-        if (platform === 'harmony') {
-          if (shouldPrintInfoAboutRNRedirection) {
-            info(
-              `Redirected imports from ${colors.bold(
-                colors.gray('react-native')
-              )} to ${colors.bold(reactNativeHarmonyName)}`
+        REQUEST_RESOLUTION_LATEST_PLATFORM = platform;
+        const nodeModulesPaths = [
+          pathUtils.resolve('node_modules'),
+          ...(ctx.nodeModulesPaths ?? []),
+        ];
+        if (platform === HARMONY_PLATFORM_NAME) {
+          if (
+            moduleName === 'react-native' ||
+            moduleName.startsWith(`react-native/`)
+          ) {
+            /**
+             * Importing from `react-native` when preparing offline bundle.
+             * For some reason there's a difference in behavior when a bundle is provided via Metro server and when creating an offline bundle.
+             */
+            const newModuleName = moduleName.replace(
+              'react-native',
+              reactNativeHarmonyPackageName
             );
-            shouldPrintInfoAboutRNRedirection = false;
-          }
-          if (moduleName === 'react-native') {
-            return ctx.resolveRequest(ctx, reactNativeHarmonyName, platform);
-          } else if (moduleName.startsWith('react-native/')) {
-            return ctx.resolveRequest(ctx, moduleName, 'ios');
+            /**
+             * Special case for a library which hijacks imports to react-native-harmony.
+             */
+            const maybeInteropLibraryResult = resolveIfInteropLibraryRequest(
+              ctx,
+              newModuleName,
+              nodeModulesPaths,
+              reactNativeHarmonyPackageName,
+              reactNativeInteropLibraryPackagePattern
+            );
+            if (maybeInteropLibraryResult) {
+              return maybeInteropLibraryResult;
+            }
+            try {
+              return ctx.resolveRequest(
+                ctx,
+                newModuleName,
+                HARMONY_PLATFORM_NAME
+              );
+            } catch {
+              return ctx.resolveRequest(
+                ctx,
+                newModuleName,
+                RNOH_FALLBACK_PLATFORM_NAME
+              );
+            }
           } else if (
-            isInternalReactNativeRelativeImport(ctx.originModulePath)
+            moduleName === reactNativeHarmonyPackageName ||
+            moduleName.startsWith(`${reactNativeHarmonyPackageName}/`)
           ) {
-            if (moduleName.startsWith('.')) {
-              const moduleAbsPath = pathUtils.resolve(
-                pathUtils.dirname(ctx.originModulePath),
-                moduleName
-              );
-              const [_, modulePathRelativeToReactNative] = moduleAbsPath.split(
-                `${pathUtils.sep}node_modules${pathUtils.sep}react-native${pathUtils.sep}`
+            /**
+             * Importing from `react-native` when bundle is provided from Metro server.
+             *
+             * `moduleName` is equal here to the value provided in
+             * react-native-harmony/react-native.config.js::config::platforms::harmony::npmPackageName
+             * when importing from `react-native`.
+             */
+
+            /**
+             * Special case for a library which hijacks imports to react-native-harmony.
+             */
+            const result = resolveIfInteropLibraryRequest(
+              ctx,
+              moduleName,
+              nodeModulesPaths,
+              reactNativeHarmonyPackageName,
+              reactNativeInteropLibraryPackagePattern
+            );
+            if (result) {
+              return result;
+            }
+
+            try {
+              return ctx.resolveRequest(ctx, moduleName, HARMONY_PLATFORM_NAME);
+            } catch {
+              return ctx.resolveRequest(
+                ctx,
+                moduleName,
+                RNOH_FALLBACK_PLATFORM_NAME
               );
-              try {
-                return ctx.resolveRequest(
-                  ctx,
-                  `${reactNativeHarmonyName}${pathUtils.sep}${modulePathRelativeToReactNative}`,
-                  'harmony'
+            }
+          } else if (ctx.originModulePath.includes(reactNativeHarmonyPattern)) {
+            const rnInteropLibraryPackage =
+              getHarmonyPackageByAliasMap(nodeModulesPaths)[
+                reactNativeHarmonyPackageName
+              ];
+            // Redirect internal react-native-harmony imports to the interop package
+            if (rnInteropLibraryPackage && moduleName.startsWith('.')) {
+              const rnInteropLibraryPackageName = rnInteropLibraryPackage.name;
+              const redirectInternalImports =
+                rnInteropLibraryPackage.redirectInternalImports;
+              if (redirectInternalImports) {
+                const moduleAbsPath = pathUtils.resolve(
+                  pathUtils.dirname(ctx.originModulePath),
+                  moduleName
                 );
-              } catch (err) {}
+
+                try {
+                  // We have to replace either /react-native-harmony/ or /@react-native-oh/react-native-harmony/ with the interop package name.
+                  const newModuleName = moduleAbsPath.replace(
+                    reactNativeHarmonyPattern,
+                    reactNativeInteropLibraryPackagePattern ??
+                      getRNInteropLibraryPackagePattern(
+                        rnInteropLibraryPackageName
+                      )
+                  );
+
+                  return ctx.resolveRequest(
+                    ctx,
+                    newModuleName,
+                    HARMONY_PLATFORM_NAME
+                  );
+                } catch {}
+              }
+            }
+            // Internal RN imports
+            const maybeResult = resolveRequestOnlyForHarmony(ctx, moduleName);
+            if (maybeResult) {
+              return maybeResult;
             }
-            return ctx.resolveRequest(ctx, moduleName, 'ios');
-          } else if(isHarmonyPackageInternalImport(ctx.originModulePath, moduleName)) {
+            return ctx.resolveRequest(
+              ctx,
+              moduleName,
+              RNOH_FALLBACK_PLATFORM_NAME
+            );
+          } else if (
+            isHarmonyPackageInternalImport(
+              nodeModulesPaths,
+              ctx.originModulePath,
+              moduleName
+            )
+          ) {
             /**
-             * Replace internal imports in `react-native-foo` with equivalent files from `react-native-harmony-foo` 
+             * Replace internal imports in `react-native-foo` with equivalent files from `react-native-harmony-foo`
              * if a package has internal import redirection enabled in its package.json configuration e.g.
              *
              * react-native-harmony-foo/package.json:
@@ -84,30 +205,52 @@ function createHarmonyMetroConfig(options) {
              *     "redirectInternalImports": true,
              *  }
              */
-            const alias = getPackageNameFromOriginModulePath(ctx.originModulePath);
+            const alias = getPackageNameFromOriginModulePath(
+              ctx.originModulePath
+            );
+
             if (alias) {
-              const harmonyPackage = getHarmonyPackageByAliasMap(".");
+              const harmonyPackage =
+                getHarmonyPackageByAliasMap(nodeModulesPaths);
+
               const harmonyPackageName = harmonyPackage[alias]?.name;
-              const redirectInternalImports = harmonyPackage[alias]?.redirectInternalImports;
-              if (harmonyPackageName && !isRequestFromHarmonyPackage(ctx.originModulePath, harmonyPackageName) && redirectInternalImports) {
+
+              const redirectInternalImports =
+                harmonyPackage[alias]?.redirectInternalImports;
+
+              if (
+                harmonyPackageName &&
+                !isRequestFromHarmonyPackage(
+                  ctx.originModulePath,
+                  harmonyPackageName
+                ) &&
+                redirectInternalImports
+              ) {
                 const moduleAbsPath = pathUtils.resolve(
                   pathUtils.dirname(ctx.originModulePath),
-                  moduleName,
+                  moduleName
                 );
+
                 const slashes = new RegExp('/', 'g');
-                const [_, modulePathRelativeToOriginalPackage] = moduleAbsPath.split(
-                  `${pathUtils.sep}node_modules${pathUtils.sep}${alias.replace(slashes, pathUtils.sep)}${pathUtils.sep}`,
-                );
+                const [_, modulePathRelativeToOriginalPackage] =
+                  moduleAbsPath.split(
+                    `${pathUtils.sep}node_modules${
+                      pathUtils.sep
+                    }${alias.replace(slashes, pathUtils.sep)}${pathUtils.sep}`
+                  );
                 const backslashes = new RegExp('\\\\', 'g');
-                const pathToHarmonyModule = `${harmonyPackageName}/${modulePathRelativeToOriginalPackage.replace(backslashes, "/")}`;
+                const newModuleName = `${harmonyPackageName}/${modulePathRelativeToOriginalPackage.replace(
+                  backslashes,
+                  '/'
+                )}`;
                 try {
                   return ctx.resolveRequest(
                     ctx,
-                    pathToHarmonyModule,
-                    'harmony',
+                    newModuleName,
+                    HARMONY_PLATFORM_NAME
                   );
-                } catch (err) {
-                }
+                } catch (err) {}
+              } else {
               }
             }
           } else {
@@ -119,7 +262,8 @@ function createHarmonyMetroConfig(options) {
              *     "alias": "react-native-foo"
              *  }
              */
-            const harmonyPackageByAlias = getHarmonyPackageByAliasMap(".");
+            const harmonyPackageByAlias =
+              getHarmonyPackageByAliasMap(nodeModulesPaths);
             const alias = getPackageName(moduleName);
             if (alias) {
               const harmonyPackageName = harmonyPackageByAlias[alias]?.name;
@@ -149,6 +293,84 @@ module.exports = {
   createHarmonyMetroConfig,
 };
 
+/**
+ * @param ctx {Parameters<NonNullable<import("metro-config").ResolverConfigT["resolveRequest"]>>[0]}
+ * @param moduleName {string}
+ * @param nodeModulesPaths {string[]}
+ * @param reactNativeHarmonyPackageName {string}
+ * @param reactNativeInteropLibraryPackagePattern {string | undefined}
+ */
+function resolveIfInteropLibraryRequest(
+  ctx,
+  moduleName,
+  nodeModulesPaths,
+  reactNativeHarmonyPackageName,
+  reactNativeInteropLibraryPackagePattern
+) {
+  const rnInteropLibraryPackageName =
+    getHarmonyPackageByAliasMap(nodeModulesPaths)[reactNativeHarmonyPackageName]
+      ?.name;
+
+  /**
+   * We have to check if the module is not resolved from interop package
+   * to prevent an infinite resolution loop caused by a circular dependency.
+   * e.g.
+   * origin module: react-native-harmony/Libraries/Image/ImageSourceUtils.js
+   * redirected to module: react-native-harmony-61-interop/Libraries/Image/ImageSourceUtils.js
+   * and react-native-harmony-61-interop/Libraries/Image/ImageSourceUtils.js imports react-native-harmony/Libraries/Image/ImageSourceUtils.js
+   * This creates a circular dependency, causing an infinite resolution loop.
+   */
+  if (
+    rnInteropLibraryPackageName &&
+    !ctx.originModulePath.includes(
+      reactNativeInteropLibraryPackagePattern ??
+        getRNInteropLibraryPackagePattern(rnInteropLibraryPackageName)
+    )
+  ) {
+    try {
+      const newModuleName = moduleName.replace(
+        reactNativeHarmonyPackageName,
+        rnInteropLibraryPackageName
+      );
+      return ctx.resolveRequest(ctx, newModuleName, HARMONY_PLATFORM_NAME);
+    } catch {}
+  }
+  return null;
+}
+
+/**
+ * Let's say we have following files:
+ * foo.js
+ * foo.harmony.tsx
+ *
+ * By default, in that situation foo.js will be resolved. This function however chooses foo.harmony.tsx.
+ * In the past, RNOH redirected imports back to the RN package, and RNOH used different extensions than original files.
+ *
+ * @param ctx {Parameters<NonNullable<import("metro-config").ResolverConfigT["resolveRequest"]>>[0]}
+ * @param moduleName {string}
+ */
+function resolveRequestOnlyForHarmony(ctx, moduleName) {
+  for (const sourceExt of ctx.sourceExts) {
+    const newCtx = { ...ctx };
+    newCtx.sourceExts = [sourceExt];
+    try {
+      const result = ctx.resolveRequest(
+        newCtx,
+        moduleName,
+        HARMONY_PLATFORM_NAME
+      );
+      if (result.type === 'sourceFile') {
+        const lastDotIndex = result.filePath.lastIndexOf('.');
+        const beforeLastDot = result.filePath.substring(0, lastDotIndex);
+        if (beforeLastDot.endsWith('.' + HARMONY_PLATFORM_NAME)) {
+          return result;
+        }
+      }
+    } catch {}
+  }
+  return null;
+}
+
 /**
  * @param moduleName {string}
  * @returns {string | null}
@@ -176,52 +398,53 @@ function getPackageName(moduleName) {
  * @returns {string}
  */
 function getPackageNameFromOriginModulePath(originModulePath) {
-  const nodeModulesPosition = originModulePath.search("node_modules");
-  const pathRelativeToNodeModules = originModulePath.substring(nodeModulesPosition);
+  const nodeModulesPosition = originModulePath.search('node_modules');
+  const pathRelativeToNodeModules =
+    originModulePath.substring(nodeModulesPosition);
   const pathSegments = pathRelativeToNodeModules.split(pathUtils.sep);
   const module = pathSegments[1];
   if (module.startsWith('@')) {
     return `${pathSegments[1]}/${pathSegments[2]}`;
-  }
-  else {
+  } else {
     return pathSegments[1];
   }
 }
 
 /**
+ * @param nodeModulesPaths {readonly string[]}
  * @param originModulePath {string}
  * @param moduleName {string}
  * @returns {boolean}
  */
-function isHarmonyPackageInternalImport(originModulePath, moduleName) {
-  if (moduleName.startsWith(".")) {
+function isHarmonyPackageInternalImport(
+  nodeModulesPaths,
+  originModulePath,
+  moduleName
+) {
+  if (moduleName.startsWith('.')) {
     const alias = getPackageNameFromOriginModulePath(originModulePath);
     const slashes = new RegExp('/', 'g');
-    if (alias && originModulePath.includes(`${pathUtils.sep}node_modules${pathUtils.sep}${alias.replace(slashes, pathUtils.sep)}${pathUtils.sep}`)) {
-      const harmonyPackage = getHarmonyPackageByAliasMap(".");
+    if (
+      alias &&
+      originModulePath.includes(
+        `${pathUtils.sep}node_modules${pathUtils.sep}${alias.replace(
+          slashes,
+          pathUtils.sep
+        )}${pathUtils.sep}`
+      )
+    ) {
+      const harmonyPackage = getHarmonyPackageByAliasMap(nodeModulesPaths);
       const harmonyPackageName = harmonyPackage[alias]?.name;
       if (
         harmonyPackageName &&
-        !isRequestFromHarmonyPackage(
-          originModulePath,
-          harmonyPackageName,
-        )
+        !isRequestFromHarmonyPackage(originModulePath, harmonyPackageName)
       ) {
         return true;
       }
     }
   }
-  return false;
-}
 
-/**
- * @param originModulePath {string}
- * @returns {boolean}
- */
-function isInternalReactNativeRelativeImport(originModulePath) {
-  return originModulePath.includes(
-    `${pathUtils.sep}node_modules${pathUtils.sep}react-native${pathUtils.sep}`
-  );
+  return false;
 }
 
 /**
@@ -232,6 +455,7 @@ function isInternalReactNativeRelativeImport(originModulePath) {
 function isRequestFromHarmonyPackage(originModulePath, harmonyPackageName) {
   const slashes = new RegExp('/', 'g');
   const packagePath = harmonyPackageName.replace(slashes, pathUtils.sep);
+
   return originModulePath.includes(
     `${pathUtils.sep}node_modules${pathUtils.sep}${packagePath}${pathUtils.sep}`
   );
@@ -243,9 +467,9 @@ function isRequestFromHarmonyPackage(originModulePath, harmonyPackageName) {
 let cachedHarmonyPackageByAliasMap = undefined;
 
 /**
- * @param projectRootPath {string}
+ * @param nodeModulesPaths {readonly string[]}
  */
-function getHarmonyPackageByAliasMap(projectRootPath) {
+function getHarmonyPackageByAliasMap(nodeModulesPaths) {
   /**
    * @type {Record<string, {name: string, redirectInternalImports: boolean}>}
    */
@@ -254,51 +478,71 @@ function getHarmonyPackageByAliasMap(projectRootPath) {
     return cachedHarmonyPackageByAliasMap;
   }
   cachedHarmonyPackageByAliasMap = findHarmonyNodeModulePaths(
-    findHarmonyNodeModuleSearchPaths(projectRootPath),
-  ).reduce((acc, harmonyNodeModulePath) => {
-    const harmonyNodeModulePathSegments = harmonyNodeModulePath.split(
-      pathUtils.sep,
-    );
-    let harmonyNodeModuleName =
-      harmonyNodeModulePathSegments[harmonyNodeModulePathSegments.length - 1];
-    if (harmonyNodeModulePathSegments.length > 1) {
-      const harmonyNodeModuleParentDirName =
-        harmonyNodeModulePathSegments[harmonyNodeModulePathSegments.length - 2];
-      if (harmonyNodeModuleParentDirName.startsWith('@')) {
-        harmonyNodeModuleName = `${harmonyNodeModuleParentDirName}/${harmonyNodeModuleName}`;
+    findHarmonyNodeModuleSearchPaths(nodeModulesPaths)
+  ).reduce(
+    (
+      acc,
+      {
+        resolvedPath: harmonyNodeModuleResolvedPath,
+        unresolvedPath: harmonyNodeModuleUnresolvedPath,
       }
-    }
-    const packageJSONPath = `${harmonyNodeModulePath}${pathUtils.sep}package.json`;
-    const packageJSON = readHarmonyModulePackageJSON(packageJSONPath);
-    const alias = packageJSON.harmony?.alias;
-    const redirectInternalImports = packageJSON?.harmony?.redirectInternalImports ?? false;
-    if (alias) {
-      acc[alias] ={
-        name: harmonyNodeModuleName,
-        redirectInternalImports: redirectInternalImports
+    ) => {
+      // use unresolved path for monorepos to find actual package name (which can be installed under an alias)
+      const harmonyNodeModulePath = harmonyNodeModuleResolvedPath.includes(
+        'node_modules'
+      )
+        ? harmonyNodeModuleResolvedPath
+        : harmonyNodeModuleUnresolvedPath;
+
+      const harmonyNodeModulePathSegments = harmonyNodeModulePath.split(
+        pathUtils.sep
+      );
+
+      let harmonyNodeModuleName =
+        harmonyNodeModulePathSegments[harmonyNodeModulePathSegments.length - 1];
+      if (harmonyNodeModulePathSegments.length > 1) {
+        const harmonyNodeModuleParentDirName =
+          harmonyNodeModulePathSegments[
+            harmonyNodeModulePathSegments.length - 2
+          ];
+        if (harmonyNodeModuleParentDirName.startsWith('@')) {
+          harmonyNodeModuleName = `${harmonyNodeModuleParentDirName}/${harmonyNodeModuleName}`;
+        }
       }
-    }
-    return acc;
-  }, initialAcc);
+      const packageJsonPath = `${harmonyNodeModuleResolvedPath}${pathUtils.sep}package.json`;
+      const packageJson = readHarmonyModulePackageJSON(packageJsonPath);
+      const alias = packageJson.harmony?.alias;
+      const redirectInternalImports =
+        packageJson?.harmony?.redirectInternalImports ?? false;
+      if (alias) {
+        acc[alias] = {
+          name: harmonyNodeModuleName,
+          redirectInternalImports: redirectInternalImports,
+        };
+      }
+      return acc;
+    },
+    initialAcc
+  );
   const harmonyPackagesCount = Object.keys(
-    cachedHarmonyPackageByAliasMap,
+    cachedHarmonyPackageByAliasMap
   ).length;
   if (harmonyPackagesCount > 0) {
     const prettyHarmonyPackagesCount = colors.bold(
       harmonyPackagesCount > 0
         ? colors.green(harmonyPackagesCount.toString())
-        : harmonyPackagesCount.toString(),
+        : harmonyPackagesCount.toString()
     );
     info(
-      `Redirected imports to ${prettyHarmonyPackagesCount} harmony-specific third-party package(s):`,
+      `Redirected imports to ${prettyHarmonyPackagesCount} harmony-specific third-party package(s):`
     );
     if (harmonyPackagesCount > 0) {
       Object.entries(cachedHarmonyPackageByAliasMap).forEach(
-        ([original, {name: alias}]) => {
+        ([original, { name: alias }]) => {
           info(
-            `• ${colors.bold(colors.gray(original))} → ${colors.bold(alias)}`,
+            `• ${colors.bold(colors.gray(original))} → ${colors.bold(alias)}`
           );
-        },
+        }
       );
     }
   } else {
@@ -309,30 +553,55 @@ function getHarmonyPackageByAliasMap(projectRootPath) {
 }
 
 /**
- * @param projectRootPath {string}
+ * @param nodeModulesPaths {readonly string[]}
  * @returns {string[]}
  */
-function findHarmonyNodeModuleSearchPaths(projectRootPath) {
-  const nodeModulesPath = `${projectRootPath}${pathUtils.sep}node_modules`;
-  const searchPaths = fs
-    .readdirSync(nodeModulesPath)
-    .filter((dirName) => dirName.startsWith('@'))
-    .map((dirName) => `${nodeModulesPath}${pathUtils.sep}${dirName}`);
-  searchPaths.push(nodeModulesPath);
+function findHarmonyNodeModuleSearchPaths(nodeModulesPaths) {
+  /**
+   * @type string[]
+   */
+  let searchPaths = [];
+  for (const nodeModulesPath of nodeModulesPaths) {
+    if (fs.existsSync(nodeModulesPath)) {
+      fs.readdirSync(nodeModulesPath)
+        .filter((dirName) => dirName.startsWith('@'))
+        .forEach((dirName) =>
+          searchPaths.push(`${nodeModulesPath}${pathUtils.sep}${dirName}`)
+        );
+      searchPaths.push(nodeModulesPath);
+    }
+  }
   return searchPaths;
 }
 
 /**
  * @param searchPaths {string[]}
- * @returns {string[]}
+ * @returns {{resolvedPath:string, unresolvedPath: string}[]}
  */
 function findHarmonyNodeModulePaths(searchPaths) {
   return searchPaths
     .map((searchPath) => {
       return fs
-        .readdirSync(searchPath)
-        .map((dirName) => `${searchPath}${pathUtils.sep}${dirName}`)
-        .filter(hasPackageJSON);
+        .readdirSync(searchPath, { withFileTypes: true })
+        .map((dirent) => {
+          const direntPath =
+            (dirent.parentPath ?? dirent.path) + pathUtils.sep + dirent.name;
+          if (dirent.isSymbolicLink()) {
+            return {
+              resolvedPath: pathUtils.resolve(
+                dirent.parentPath ?? dirent.path,
+                fs.readlinkSync(direntPath)
+              ),
+              unresolvedPath: pathUtils.resolve(
+                dirent.parentPath ?? dirent.path,
+                direntPath
+              ),
+            };
+          } else {
+            return { resolvedPath: direntPath, unresolvedPath: direntPath };
+          }
+        })
+        .filter(({ resolvedPath }) => hasPackageJSON(resolvedPath));
     })
     .flat();
 }
@@ -342,7 +611,12 @@ function findHarmonyNodeModulePaths(searchPaths) {
  * @returns {boolean}
  */
 function hasPackageJSON(nodeModulePath) {
-  if (!fs.lstatSync(nodeModulePath).isDirectory()) return false;
+  if (!fs.existsSync(nodeModulePath)) {
+    return false;
+  }
+  if (!fs.lstatSync(nodeModulePath).isDirectory()) {
+    return false;
+  }
   const nodeModuleContentNames = fs.readdirSync(nodeModulePath);
   return nodeModuleContentNames.includes('package.json');
 }
@@ -354,3 +628,12 @@ function hasPackageJSON(nodeModulePath) {
 function readHarmonyModulePackageJSON(packageJSONPath) {
   return JSON.parse(fs.readFileSync(packageJSONPath).toString());
 }
+
+/**
+ * @param rnInteropLibraryPackageName {string}
+ * @param isInMonorepo {boolean}
+ * @returns {string} - Either package name without the scope or the full package name with platform specific separator
+ */
+function getRNInteropLibraryPackagePattern(rnInteropLibraryPackageName) {
+  return `${pathUtils.sep}${rnInteropLibraryPackageName.replace('/', pathUtils.sep)}${pathUtils.sep}`;
+}