react-native 0.69.3 → 0.70.0-rc.2

package/scripts/cocoapods/utils.rb

@@ -0,0 +1,154 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+require_relative "./helpers.rb"
+
+# Utilities class for React Native Cocoapods
+class ReactNativePodsUtils
+    def self.warn_if_not_on_arm64
+        if SysctlChecker.new().call_sysctl_arm64() == 1 && !Environment.new().ruby_platform().include?('arm64')
+            Pod::UI.warn 'Do not use "pod install" from inside Rosetta2 (x86_64 emulation on arm64).'
+            Pod::UI.warn ' - Emulated x86_64 is slower than native arm64'
+            Pod::UI.warn ' - May result in mixed architectures in rubygems (eg: ffi_c.bundle files may be x86_64 with an arm64 interpreter)'
+            Pod::UI.warn 'Run "env /usr/bin/arch -arm64 /bin/bash --login" then try again.'
+        end
+    end
+
+    def self.get_default_flags
+        flags = {
+            :fabric_enabled => false,
+            :hermes_enabled => true,
+            :flipper_configuration => FlipperConfiguration.disabled
+        }
+
+        if ENV['RCT_NEW_ARCH_ENABLED'] == '1'
+            flags[:fabric_enabled] = true
+            flags[:hermes_enabled] = true
+        end
+
+        if ENV['USE_HERMES'] == '0'
+            flags[:hermes_enabled] = false
+        end
+
+        return flags
+    end
+
+    def self.has_pod(installer, name)
+        installer.pods_project.pod_group(name) != nil
+    end
+
+    def self.exclude_i386_architecture_while_using_hermes(installer)
+        projects = installer.aggregate_targets
+            .map{ |t| t.user_project }
+            .uniq{ |p| p.path }
+            .push(installer.pods_project)
+
+
+        # Hermes does not support `i386` architecture
+        excluded_archs_default = ReactNativePodsUtils.has_pod(installer, 'hermes-engine') ? "i386" : ""
+
+        projects.each do |project|
+            project.build_configurations.each do |config|
+                config.build_settings["EXCLUDED_ARCHS[sdk=iphonesimulator*]"] = excluded_archs_default
+            end
+
+            project.save()
+        end
+    end
+
+    def self.set_node_modules_user_settings(installer, react_native_path)
+        Pod::UI.puts("Setting REACT_NATIVE build settings")
+        projects = installer.aggregate_targets
+            .map{ |t| t.user_project }
+            .uniq{ |p| p.path }
+            .push(installer.pods_project)
+
+        projects.each do |project|
+            project.build_configurations.each do |config|
+                config.build_settings["REACT_NATIVE_PATH"] = File.join("${PODS_ROOT}", "..", react_native_path)
+            end
+
+            project.save()
+        end
+    end
+
+    def self.fix_library_search_paths(installer)
+        projects = installer.aggregate_targets
+            .map{ |t| t.user_project }
+            .uniq{ |p| p.path }
+            .push(installer.pods_project)
+
+        projects.each do |project|
+            project.build_configurations.each do |config|
+                ReactNativePodsUtils.fix_library_search_path(config)
+            end
+            project.native_targets.each do |target|
+                target.build_configurations.each do |config|
+                    ReactNativePodsUtils.fix_library_search_path(config)
+                end
+            end
+            project.save()
+        end
+    end
+
+    def self.fix_react_bridging_header_search_paths(installer)
+        installer.target_installation_results.pod_target_installation_results
+            .each do |pod_name, target_installation_result|
+                target_installation_result.native_target.build_configurations.each do |config|
+                    # For third party modules who have React-bridging dependency to search correct headers
+                    config.build_settings['HEADER_SEARCH_PATHS'] ||= '$(inherited) '
+                    config.build_settings['HEADER_SEARCH_PATHS'] << '"$(PODS_ROOT)/Headers/Private/React-bridging/react/bridging" '
+                    config.build_settings['HEADER_SEARCH_PATHS'] << '"$(PODS_CONFIGURATION_BUILD_DIR)/React-bridging/react_bridging.framework/Headers" '
+            end
+        end
+    end
+
+    def self.apply_mac_catalyst_patches(installer)
+        # Fix bundle signing issues
+        installer.pods_project.targets.each do |target|
+            if target.respond_to?(:product_type) and target.product_type == "com.apple.product-type.bundle"
+                target.build_configurations.each do |config|
+                    config.build_settings['CODE_SIGN_IDENTITY[sdk=macosx*]'] = '-'
+                end
+            end
+        end
+
+        installer.aggregate_targets.each do |aggregate_target|
+            aggregate_target.user_project.native_targets.each do |target|
+                target.build_configurations.each do |config|
+                    # Explicitly set dead code stripping flags
+                    config.build_settings['DEAD_CODE_STRIPPING'] = 'YES'
+                    config.build_settings['PRESERVE_DEAD_CODE_INITS_AND_TERMS'] = 'YES'
+                    # Modify library search paths
+                    config.build_settings['LIBRARY_SEARCH_PATHS'] = ['$(SDKROOT)/usr/lib/swift', '$(SDKROOT)/System/iOSSupport/usr/lib/swift', '$(inherited)']
+                end
+            end
+            aggregate_target.user_project.save()
+        end
+    end
+
+    private
+
+    def self.fix_library_search_path(config)
+        lib_search_paths = config.build_settings["LIBRARY_SEARCH_PATHS"]
+
+        if lib_search_paths == nil
+            # No search paths defined, return immediately
+            return
+        end
+
+        # $(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME) causes problem with Xcode 12.5 + arm64 (Apple M1)
+        # since the libraries there are only built for x86_64 and i386.
+        lib_search_paths.delete("$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)")
+        lib_search_paths.delete("\"$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)\"")
+
+        if !(lib_search_paths.include?("$(SDKROOT)/usr/lib/swift") || lib_search_paths.include?("\"$(SDKROOT)/usr/lib/swift\""))
+            # however, $(SDKROOT)/usr/lib/swift is required, at least if user is not running CocoaPods 1.11
+            lib_search_paths.insert(0, "$(SDKROOT)/usr/lib/swift")
+        end
+    end
+
+
+end

package/scripts/codegen/codegen-utils.js

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+'use strict';
+
+/**
+ * Wrapper required to abstract away from the actual codegen.
+ * This is needed because, when running tests in Sandcastle, not everything is setup as usually.
+ * For example, the `react-native-codegen` lib is not present.
+ *
+ * Thanks to this wrapper, we are able to mock the getter for the codegen in a way that allow us to return
+ * a custom object which mimics the Codegen interface.
+ *
+ * @return an object that can generate the code for the New Architecture.
+ */
+function getCodegen() {
+  let RNCodegen;
+  try {
+    RNCodegen = require('../../packages/react-native-codegen/lib/generators/RNCodegen.js');
+  } catch (e) {
+    RNCodegen = require('react-native-codegen/lib/generators/RNCodegen.js');
+  }
+  if (!RNCodegen) {
+    throw 'RNCodegen not found.';
+  }
+  return RNCodegen;
+}
+
+module.exports = {
+  getCodegen: getCodegen,
+};

package/scripts/codegen/generate-artifacts-executor.js

@@ -0,0 +1,481 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+'use strict';
+
+/**
+ * This script crawls through a React Native application's dependencies and invokes the codegen
+ * for any libraries that require it.
+ * To enable codegen support, the library should include a config in the codegenConfigKey key
+ * in a codegenConfigFilename file.
+ */
+
+const {execSync} = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const RN_ROOT = path.join(__dirname, '../..');
+
+const CODEGEN_REPO_PATH = `${RN_ROOT}/packages/react-native-codegen`;
+const CODEGEN_NPM_PATH = `${RN_ROOT}/../react-native-codegen`;
+const CORE_LIBRARIES = new Set(['rncore', 'FBReactNativeSpec']);
+const REACT_NATIVE_DEPENDENCY_NAME = 'react-native';
+
+// HELPERS
+
+function isReactNativeCoreLibrary(libraryName) {
+  return CORE_LIBRARIES.has(libraryName);
+}
+
+function executeNodeScript(node, script) {
+  execSync(`${node} ${script}`);
+}
+
+function isAppRootValid(appRootDir) {
+  if (appRootDir == null) {
+    console.error('Missing path to React Native application');
+    process.exitCode = 1;
+    return false;
+  }
+  return true;
+}
+
+function readPackageJSON(appRootDir) {
+  return JSON.parse(fs.readFileSync(path.join(appRootDir, 'package.json')));
+}
+
+// Reading Libraries
+function extractLibrariesFromConfigurationArray(
+  configFile,
+  codegenConfigKey,
+  libraries,
+  dependency,
+  dependencyPath,
+) {
+  console.log(`[Codegen] Found ${dependency}`);
+  configFile[codegenConfigKey].libraries.forEach(config => {
+    const libraryConfig = {
+      library: dependency,
+      config,
+      libraryPath: dependencyPath,
+    };
+    libraries.push(libraryConfig);
+  });
+}
+
+function extractLibrariesFromJSON(
+  configFile,
+  libraries,
+  codegenConfigKey,
+  dependency,
+  dependencyPath,
+) {
+  var isBlocking = false;
+  if (dependency == null) {
+    dependency = REACT_NATIVE_DEPENDENCY_NAME;
+    dependencyPath = RN_ROOT;
+    // If we are exploring the ReactNative libraries, we want to raise an error
+    // if the codegen is not properly configured.
+    isBlocking = true;
+  }
+
+  if (configFile[codegenConfigKey] == null) {
+    if (isBlocking) {
+      throw `[Codegen] Error: Could not find codegen config for ${dependency} .`;
+    }
+    return;
+  }
+
+  if (configFile[codegenConfigKey].libraries == null) {
+    console.log(`[Codegen] Found ${dependency}`);
+    var config = configFile[codegenConfigKey];
+    libraries.push({
+      library: dependency,
+      config,
+      libraryPath: dependencyPath,
+    });
+  } else {
+    console.log(`[Codegen] CodegenConfig Deprecated Setup for ${dependency}.
+      The configuration file still contains the codegen in the libraries array.
+      If possible, replace it with a single object.
+    `);
+    console.debug(`BEFORE:
+      {
+        // ...
+        "codegenConfig": {
+          "libraries": [
+            {
+              "name": "libName1",
+              "type": "all|components|modules",
+              "jsSrcsRoot": "libName1/js"
+            },
+            {
+              "name": "libName2",
+              "type": "all|components|modules",
+              "jsSrcsRoot": "libName2/src"
+            }
+          ]
+        }
+      }
+
+      AFTER:
+      {
+        "codegenConfig": {
+          "name": "libraries",
+          "type": "all",
+          "jsSrcsRoot": "."
+        }
+      }
+    `);
+    extractLibrariesFromConfigurationArray(
+      configFile,
+      codegenConfigKey,
+      libraries,
+      dependency,
+      dependencyPath,
+    );
+  }
+}
+
+function handleReactNativeCodeLibraries(
+  libraries,
+  codegenConfigFilename,
+  codegenConfigKey,
+) {
+  // Handle react-native core libraries.
+  // This is required when react-native is outside of node_modules.
+  console.log('[Codegen] Processing react-native core libraries');
+  const reactNativePkgJson = path.join(RN_ROOT, codegenConfigFilename);
+  if (!fs.existsSync(reactNativePkgJson)) {
+    throw '[Codegen] Error: Could not find config file for react-native.';
+  }
+  const reactNativeConfigFile = JSON.parse(fs.readFileSync(reactNativePkgJson));
+  extractLibrariesFromJSON(reactNativeConfigFile, libraries, codegenConfigKey);
+}
+
+function handleThirdPartyLibraries(
+  libraries,
+  baseCodegenConfigFileDir,
+  dependencies,
+  codegenConfigFilename,
+  codegenConfigKey,
+) {
+  // Determine which of these are codegen-enabled libraries
+  const configDir = baseCodegenConfigFileDir || path.join(RN_ROOT, '..');
+  console.log(
+    `\n\n[Codegen] >>>>> Searching for codegen-enabled libraries in ${configDir}`,
+  );
+
+  // Handle third-party libraries
+  Object.keys(dependencies).forEach(dependency => {
+    if (dependency === REACT_NATIVE_DEPENDENCY_NAME) {
+      // react-native should already be added.
+      return;
+    }
+    const codegenConfigFileDir = path.join(configDir, dependency);
+    const configFilePath = path.join(
+      codegenConfigFileDir,
+      codegenConfigFilename,
+    );
+    if (fs.existsSync(configFilePath)) {
+      const configFile = JSON.parse(fs.readFileSync(configFilePath));
+      extractLibrariesFromJSON(
+        configFile,
+        libraries,
+        codegenConfigKey,
+        dependency,
+        codegenConfigFileDir,
+      );
+    }
+  });
+}
+
+function handleInAppLibraries(
+  libraries,
+  pkgJson,
+  codegenConfigKey,
+  appRootDir,
+) {
+  console.log(
+    '\n\n[Codegen] >>>>> Searching for codegen-enabled libraries in the app',
+  );
+
+  extractLibrariesFromJSON(
+    pkgJson,
+    libraries,
+    codegenConfigKey,
+    pkgJson.name,
+    appRootDir,
+  );
+}
+
+// CodeGen
+
+function getCodeGenCliPath() {
+  let codegenCliPath;
+  if (fs.existsSync(CODEGEN_REPO_PATH)) {
+    codegenCliPath = CODEGEN_REPO_PATH;
+
+    if (!fs.existsSync(path.join(CODEGEN_REPO_PATH, 'lib'))) {
+      console.log('\n\n[Codegen] >>>>> Building react-native-codegen package');
+      execSync('yarn install', {
+        cwd: codegenCliPath,
+        stdio: 'inherit',
+      });
+      execSync('yarn build', {
+        cwd: codegenCliPath,
+        stdio: 'inherit',
+      });
+    }
+  } else if (fs.existsSync(CODEGEN_NPM_PATH)) {
+    codegenCliPath = CODEGEN_NPM_PATH;
+  } else {
+    throw "error: Could not determine react-native-codegen location. Try running 'yarn install' or 'npm install' in your project root.";
+  }
+  return codegenCliPath;
+}
+
+function computeIOSOutputDir(outputPath, appRootDir) {
+  return path.join(outputPath ? outputPath : appRootDir, 'build/generated/ios');
+}
+
+function generateSchema(tmpDir, library, node, codegenCliPath) {
+  const pathToSchema = path.join(tmpDir, 'schema.json');
+  const pathToJavaScriptSources = path.join(
+    library.libraryPath,
+    library.config.jsSrcsDir,
+  );
+
+  console.log(`\n\n[Codegen] >>>>> Processing ${library.config.name}`);
+  // Generate one schema for the entire library...
+  executeNodeScript(
+    node,
+    `${path.join(
+      codegenCliPath,
+      'lib',
+      'cli',
+      'combine',
+      'combine-js-to-schema-cli.js',
+    )} ${pathToSchema} ${pathToJavaScriptSources}`,
+  );
+  console.log(`[Codegen] Generated schema: ${pathToSchema}`);
+  return pathToSchema;
+}
+
+function generateCode(iosOutputDir, library, tmpDir, node, pathToSchema) {
+  // ...then generate native code artifacts.
+  const libraryTypeArg = library.config.type
+    ? `--libraryType ${library.config.type}`
+    : '';
+
+  const tmpOutputDir = path.join(tmpDir, 'out');
+  fs.mkdirSync(tmpOutputDir, {recursive: true});
+
+  executeNodeScript(
+    node,
+    `${path.join(RN_ROOT, 'scripts', 'generate-specs-cli.js')} \
+        --platform ios \
+        --schemaPath ${pathToSchema} \
+        --outputDir ${tmpOutputDir} \
+        --libraryName ${library.config.name} \
+        ${libraryTypeArg}`,
+  );
+
+  // Finally, copy artifacts to the final output directory.
+  fs.mkdirSync(iosOutputDir, {recursive: true});
+  execSync(`cp -R ${tmpOutputDir}/* ${iosOutputDir}`);
+  console.log(`[Codegen] Generated artifacts: ${iosOutputDir}`);
+}
+
+function generateNativeCodegenFiles(
+  libraries,
+  fabricEnabled,
+  iosOutputDir,
+  node,
+  codegenCliPath,
+  schemaPaths,
+) {
+  let fabricEnabledTypes = ['components', 'all'];
+  libraries.forEach(library => {
+    if (
+      !fabricEnabled &&
+      fabricEnabledTypes.indexOf(library.config.type) >= 0
+    ) {
+      console.log(
+        `[Codegen] ${library.config.name} skipped because fabric is not enabled.`,
+      );
+      return;
+    }
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), library.config.name));
+    const pathToSchema = generateSchema(tmpDir, library, node, codegenCliPath);
+    generateCode(iosOutputDir, library, tmpDir, node, pathToSchema);
+
+    // Filter the react native core library out.
+    // In the future, core library and third party library should
+    // use the same way to generate/register the fabric components.
+    if (!isReactNativeCoreLibrary(library.config.name)) {
+      schemaPaths[library.config.name] = pathToSchema;
+    }
+  });
+}
+
+function createComponentProvider(
+  fabricEnabled,
+  schemaPaths,
+  node,
+  iosOutputDir,
+) {
+  if (fabricEnabled) {
+    console.log('\n\n>>>>> Creating component provider');
+    // Save the list of spec paths to a temp file.
+    const schemaListTmpPath = `${os.tmpdir()}/rn-tmp-schema-list.json`;
+    const fd = fs.openSync(schemaListTmpPath, 'w');
+    fs.writeSync(fd, JSON.stringify(schemaPaths));
+    fs.closeSync(fd);
+    console.log(`Generated schema list: ${schemaListTmpPath}`);
+
+    // Generate FabricComponentProvider.
+    // Only for iOS at this moment.
+    executeNodeScript(
+      node,
+      `${path.join(
+        RN_ROOT,
+        'scripts',
+        'generate-provider-cli.js',
+      )} --platform ios --schemaListPath "${schemaListTmpPath}" --outputDir ${iosOutputDir}`,
+    );
+    console.log(`Generated provider in: ${iosOutputDir}`);
+  }
+}
+
+// It removes all the empty files and empty folders
+// it finds, starting from `filepath`, recursively.
+//
+// This function is needed since, after aligning the codegen between
+// iOS and Android, we have to create empty folders in advance and
+// we don't know wheter they will be populated up until the end of the process.
+//
+// @parameter filepath: the root path from which we want to remove the empty files and folders.
+function cleanupEmptyFilesAndFolders(filepath) {
+  const stats = fs.statSync(filepath);
+
+  if (stats.isFile() && stats.size === 0) {
+    fs.rmSync(filepath);
+    return;
+  } else if (stats.isFile()) {
+    return;
+  }
+
+  const dirContent = fs.readdirSync(filepath);
+  dirContent.forEach(contentPath =>
+    cleanupEmptyFilesAndFolders(path.join(filepath, contentPath)),
+  );
+
+  // The original folder may be filled with empty folders
+  // if that the case, we would also like to remove the parent.
+  // Hence, we need to read the folder again.
+  const newContent = fs.readdirSync(filepath);
+  if (newContent.length === 0) {
+    fs.rmdirSync(filepath);
+    return;
+  }
+}
+
+// Execute
+
+/**
+ * This function is the entry point for the codegen. It:
+ * - reads the package json
+ * - extracts the libraries
+ * - setups the CLI to generate the code
+ * - generate the code
+ *
+ * @parameter appRootDir: the directory with the app source code, where the `codegenConfigFilename` lives.
+ * @parameter outputPath: the base output path for the CodeGen.
+ * @parameter node: the path to the node executable, used to run the codegen scripts.
+ * @parameter codegenConfigFilename: the file that contains the codeGen configuration. The default is `package.json`.
+ * @parameter codegenConfigKey: the key in the codegenConfigFile that controls the codegen.
+ * @parameter baseCodegenConfigFileDir: the directory of the codeGenConfigFile.
+ * @parameter fabricEnabled: whether fabric is enabled or not.
+ * @throws If it can't find a config file for react-native.
+ * @throws If it can't find a CodeGen configuration in the file.
+ * @throws If it can't find a cli for the CodeGen.
+ */
+function execute(
+  appRootDir,
+  outputPath,
+  node,
+  codegenConfigFilename,
+  codegenConfigKey,
+  baseCodegenConfigFileDir,
+  fabricEnabled,
+) {
+  if (!isAppRootValid(appRootDir)) {
+    return;
+  }
+
+  try {
+    const pkgJson = readPackageJSON(appRootDir);
+    const dependencies = {...pkgJson.dependencies, ...pkgJson.devDependencies};
+    const libraries = [];
+
+    handleReactNativeCodeLibraries(
+      libraries,
+      codegenConfigFilename,
+      codegenConfigKey,
+    );
+    handleThirdPartyLibraries(
+      libraries,
+      baseCodegenConfigFileDir,
+      dependencies,
+      codegenConfigFilename,
+      codegenConfigKey,
+    );
+    handleInAppLibraries(libraries, pkgJson, codegenConfigKey, appRootDir);
+
+    if (libraries.length === 0) {
+      console.log('[Codegen] No codegen-enabled libraries found.');
+      return;
+    }
+
+    const codegenCliPath = getCodeGenCliPath();
+
+    const schemaPaths = {};
+
+    const iosOutputDir = computeIOSOutputDir(outputPath, appRootDir);
+
+    generateNativeCodegenFiles(
+      libraries,
+      fabricEnabled,
+      iosOutputDir,
+      node,
+      codegenCliPath,
+      schemaPaths,
+    );
+
+    createComponentProvider(fabricEnabled, schemaPaths, node, iosOutputDir);
+    cleanupEmptyFilesAndFolders(iosOutputDir);
+  } catch (err) {
+    console.error(err);
+    process.exitCode = 1;
+  }
+
+  console.log('\n\n[Codegen] Done.');
+  return;
+}
+
+module.exports = {
+  execute: execute,
+  // exported for testing purposes only:
+  _extractLibrariesFromJSON: extractLibrariesFromJSON,
+  _executeNodeScript: executeNodeScript,
+  _generateCode: generateCode,
+  _cleanupEmptyFilesAndFolders: cleanupEmptyFilesAndFolders,
+};