react-native-tvos 0.80.1-0 → 0.81.0-0rc2

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

@@ -4,6 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
+ * @flow strict-local
  * @format
  */
 
@@ -15,11 +16,17 @@ const fs = require('fs');
 const glob = require('glob');
 const path = require('path');
 
-function generateSchemaInfos(libraries) {
+function generateSchemaInfos(
+  libraries /*: $ReadOnlyArray<$FlowFixMe> */,
+) /*: Array<$FlowFixMe> */ {
+  // $FlowFixMe[incompatible-call]
   return libraries.map(generateSchemaInfo);
 }
 
-function generateSchemaInfo(library, platform) {
+function generateSchemaInfo(
+  library /*: $FlowFixMe */,
+  platform /*: string */,
+) /*: $FlowFixMe */ {
   const pathToJavaScriptSources = path.join(
     library.libraryPath,
     library.config.jsSrcsDir,
@@ -45,7 +52,10 @@ function generateSchemaInfo(library, platform) {
 
 const APPLE_PLATFORMS = ['ios', 'macos', 'tvos', 'visionos'];
 
-function extractSupportedApplePlatforms(dependency, dependencyPath) {
+function extractSupportedApplePlatforms(
+  dependency /*: string */,
+  dependencyPath /*: string */,
+) /*: ?{[string]: boolean} */ {
   codegenLog('Searching for podspec in the project dependencies.', true);
   const podspecs = glob.sync('*.podspec', {cwd: dependencyPath});
 
@@ -80,7 +90,7 @@ function extractSupportedApplePlatforms(dependency, dependencyPath) {
         getCocoaPodsPlatformKey(platform),
       ),
     }),
-    {},
+    {} /*:: as {[string]: boolean} */,
   );
 
   const supportedPlatformsList = Object.keys(supportedPlatformsMap).filter(
@@ -99,7 +109,7 @@ function extractSupportedApplePlatforms(dependency, dependencyPath) {
 }
 
 // Cocoapods specific platform keys
-function getCocoaPodsPlatformKey(platformName) {
+function getCocoaPodsPlatformKey(platformName /*: string */) {
   if (platformName === 'macos') {
     return 'osx';
   }

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

@@ -4,6 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
+ * @flow strict-local
  * @format
  */
 
@@ -27,12 +28,12 @@ const UNSTABLE_MODULES_REQUIRING_MAIN_QUEUE_SETUP_PROVIDER_MM_TEMPLATE_PATH =
   );
 
 function generateUnstableModulesRequiringMainQueueSetupProvider(
-  libraries,
-  outputDir,
+  libraries /*: $ReadOnlyArray<$FlowFixMe> */,
+  outputDir /*: string */,
 ) {
   const iosAnnotations = parseiOSAnnotations(libraries);
 
-  const modulesRequiringMainQueueSetup = new Set();
+  const modulesRequiringMainQueueSetup = new Set /*::<string>*/();
 
   // Old API
   libraries.forEach(library => {

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

@@ -4,6 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
+ * @flow strict-local
  * @format
  */
 
@@ -58,11 +59,11 @@ const path = require('path');
  * @throws If it can't find a cli for the CodeGen.
  */
 function execute(
-  projectRoot,
-  targetPlatform,
-  baseOutputPath,
-  source,
-  runReactNativeCodegen = true,
+  projectRoot /*: string */,
+  targetPlatform /*: string */,
+  baseOutputPath /*: string */,
+  source /*: string */,
+  runReactNativeCodegen /*: boolean */ = true,
 ) {
   try {
     codegenLog(`Analyzing ${path.join(projectRoot, 'package.json')}`);
@@ -161,7 +162,10 @@ function execute(
   return;
 }
 
-function readOutputDirFromPkgJson(pkgJson, platform) {
+function readOutputDirFromPkgJson(
+  pkgJson /*: $FlowFixMe */,
+  platform /*: string */,
+) {
   const codegenConfig = pkgJson.codegenConfig;
   if (codegenConfig == null || typeof codegenConfig !== 'object') {
     return null;
@@ -179,12 +183,19 @@ function readOutputDirFromPkgJson(pkgJson, platform) {
   return null;
 }
 
-function computeOutputPath(projectRoot, baseOutputPath, pkgJson, platform) {
+function computeOutputPath(
+  projectRoot /*: string */,
+  baseOutputPath /*: string */,
+  pkgJson /*: $FlowFixMe */,
+  platform /*: string */,
+) {
   if (baseOutputPath == null) {
     const outputDirFromPkgJson = readOutputDirFromPkgJson(pkgJson, platform);
     if (outputDirFromPkgJson != null) {
+      // $FlowFixMe[reassign-const]
       baseOutputPath = path.join(projectRoot, outputDirFromPkgJson);
     } else {
+      // $FlowFixMe[reassign-const]
       baseOutputPath = projectRoot;
     }
   }
@@ -201,7 +212,7 @@ function computeOutputPath(projectRoot, baseOutputPath, pkgJson, platform) {
   return baseOutputPath;
 }
 
-function defaultOutputPathForAndroid(baseOutputPath) {
+function defaultOutputPathForAndroid(baseOutputPath /*: string */) {
   return path.join(
     baseOutputPath,
     'android',
@@ -213,11 +224,14 @@ function defaultOutputPathForAndroid(baseOutputPath) {
   );
 }
 
-function defaultOutputPathForIOS(baseOutputPath) {
+function defaultOutputPathForIOS(baseOutputPath /*: string */) {
   return path.join(baseOutputPath, 'build', 'generated', 'ios');
 }
 
-function mustGenerateNativeCode(includeLibraryPath, schemaInfo) {
+function mustGenerateNativeCode(
+  includeLibraryPath /*: string */,
+  schemaInfo /*: $FlowFixMe */,
+) {
   // If library's 'codegenConfig' sets 'includesGeneratedCode' to 'true',
   // then we assume that native code is shipped with the library,
   // and we don't need to generate it.

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

@@ -4,6 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
+ * @flow strict-local
  * @format
  */
 
@@ -17,11 +18,13 @@ const {execSync} = require('child_process');
 const fs = require('fs');
 const path = require('path');
 
-function pkgJsonIncludesGeneratedCode(pkgJson) {
+function pkgJsonIncludesGeneratedCode(
+  pkgJson /*: $FlowFixMe */,
+) /*: boolean */ {
   return pkgJson.codegenConfig && pkgJson.codegenConfig.includesGeneratedCode;
 }
 
-const codegenLog = (text, info = false) => {
+const codegenLog = (text /*: string */, info /*: boolean */ = false) => {
   // ANSI escape codes for colors and formatting
   const reset = '\x1b[0m';
   const cyan = '\x1b[36m';
@@ -32,12 +35,12 @@ const codegenLog = (text, info = false) => {
   console.log(`${cyan}${bold}[Codegen]${reset} ${color}${text}${reset}`);
 };
 
-function readPkgJsonInDirectory(dir) {
+function readPkgJsonInDirectory(dir /*: string */) /*: $FlowFixMe */ {
   const pkgJsonPath = path.join(dir, 'package.json');
   if (!fs.existsSync(pkgJsonPath)) {
     throw `[Codegen] Error: ${pkgJsonPath} does not exist.`;
   }
-  return JSON.parse(fs.readFileSync(pkgJsonPath));
+  return JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
 }
 
 function buildCodegenIfNeeded() {
@@ -69,7 +72,7 @@ function buildCodegenIfNeeded() {
 // we don't know whether 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) {
+function cleanupEmptyFilesAndFolders(filepath /*: string */) {
   const stats = fs.statSync(filepath);
 
   if (stats.isFile() && stats.size === 0) {
@@ -94,20 +97,25 @@ function cleanupEmptyFilesAndFolders(filepath) {
   }
 }
 
-function readReactNativeConfig(projectRoot) {
+function readReactNativeConfig(projectRoot /*: string */) /*: $FlowFixMe */ {
   const rnConfigFilePath = path.resolve(projectRoot, 'react-native.config.js');
 
   if (!fs.existsSync(rnConfigFilePath)) {
     return {};
   }
 
+  // $FlowIgnore[unsupported-syntax]
   return require(rnConfigFilePath);
 }
 
 /**
  * Finding libraries!
  */
-function findCodegenEnabledLibraries(pkgJson, projectRoot, reactNativeConfig) {
+function findCodegenEnabledLibraries(
+  pkgJson /*: $FlowFixMe */,
+  projectRoot /*: string */,
+  reactNativeConfig /*: $FlowFixMe */,
+) /*: Array<$FlowFixMe> */ {
   const projectLibraries = findProjectRootLibraries(pkgJson, projectRoot);
   if (pkgJsonIncludesGeneratedCode(pkgJson)) {
     return projectLibraries;
@@ -120,7 +128,10 @@ function findCodegenEnabledLibraries(pkgJson, projectRoot, reactNativeConfig) {
   }
 }
 
-function findProjectRootLibraries(pkgJson, projectRoot) {
+function findProjectRootLibraries(
+  pkgJson /*: $FlowFixMe */,
+  projectRoot /*: string */,
+) /*: Array<$FlowFixMe> */ {
   codegenLog('Searching for codegen-enabled libraries in the app.', true);
 
   if (pkgJson.codegenConfig == null) {
@@ -138,7 +149,10 @@ function findProjectRootLibraries(pkgJson, projectRoot) {
   return extractLibrariesFromJSON(pkgJson, projectRoot);
 }
 
-function findLibrariesFromReactNativeConfig(projectRoot, rnConfig) {
+function findLibrariesFromReactNativeConfig(
+  projectRoot /*: string */,
+  rnConfig /*: $FlowFixMe */,
+) /*: Array<$FlowFixMe> */ {
   codegenLog(
     `Searching for codegen-enabled libraries in react-native.config.js`,
     true,
@@ -168,12 +182,15 @@ function findLibrariesFromReactNativeConfig(projectRoot, rnConfig) {
   });
 }
 
-function findExternalLibraries(pkgJson, projectRoot) {
+function findExternalLibraries(
+  pkgJson /*: $FlowFixMe */,
+  projectRoot /*: string */,
+) /*: Array<$FlowFixMe> */ {
   const dependencies = {
     ...pkgJson.dependencies,
     ...pkgJson.devDependencies,
     ...pkgJson.peerDependencies,
-    'react-native-tvos': '*',
+    "react-native-tvos": "*",
   };
   // Determine which of these are codegen-enabled libraries
   codegenLog(
@@ -202,13 +219,16 @@ function findExternalLibraries(pkgJson, projectRoot) {
         return [];
       }
     }
-    const configFile = JSON.parse(fs.readFileSync(configFilePath));
+    const configFile = JSON.parse(fs.readFileSync(configFilePath, 'utf8'));
     const codegenConfigFileDir = path.dirname(configFilePath);
     return extractLibrariesFromJSON(configFile, codegenConfigFileDir);
   });
 }
 
-function extractLibrariesFromJSON(configFile, dependencyPath) {
+function extractLibrariesFromJSON(
+  configFile /*: $FlowFixMe */,
+  dependencyPath /*: string */,
+) /*: Array<$FlowFixMe> */ {
   if (configFile.codegenConfig == null) {
     return [];
   }
@@ -228,7 +248,7 @@ function extractLibrariesFromJSON(configFile, dependencyPath) {
   }
 }
 
-function printDeprecationWarningIfNeeded(dependency) {
+function printDeprecationWarningIfNeeded(dependency /*: string */) {
   if (dependency === REACT_NATIVE) {
     return;
   }
@@ -266,7 +286,10 @@ function printDeprecationWarningIfNeeded(dependency) {
   `);
 }
 
-function extractLibrariesFromConfigurationArray(configFile, dependencyPath) {
+function extractLibrariesFromConfigurationArray(
+  configFile /*: $FlowFixMe */,
+  dependencyPath /*: string */,
+) {
   return configFile.codegenConfig.libraries.map(config => {
     return {
       name: config.name,
@@ -276,7 +299,7 @@ function extractLibrariesFromConfigurationArray(configFile, dependencyPath) {
   });
 }
 
-function isReactNativeCoreLibrary(libraryName) {
+function isReactNativeCoreLibrary(libraryName /*: string */) /*: boolean */ {
   return libraryName in CORE_LIBRARIES_WITH_OUTPUT_FOLDER;
 }
 
@@ -302,9 +325,11 @@ function isReactNativeCoreLibrary(libraryName) {
  * Validates that modules are defined in at most one library.
  * Validates that components are defined in at most one library.
  */
-function parseiOSAnnotations(libraries) {
-  const mLibraryMap = {};
-  const cLibraryMap = {};
+function parseiOSAnnotations(
+  libraries /*: $ReadOnlyArray<$FlowFixMe> */,
+) /*: {[string]: $FlowFixMe} */ {
+  const mLibraryMap = {} /*:: as {[string]: $FlowFixMe} */;
+  const cLibraryMap = {} /*:: as {[string]: $FlowFixMe} */;
   const map = {};
 
   for (const library of libraries) {
@@ -354,7 +379,7 @@ function parseiOSAnnotations(libraries) {
       return `  Component { "${moduleName}" } => Libraries{ ${libraryNamesString} }\n`;
     });
 
-  if (moduleConflicts.length > 0 || componentConflicts.legnth > 0) {
+  if (moduleConflicts.length > 0 || componentConflicts.length > 0) {
     throw new Error(
       'Some components or modules are declared in more than one libraries: \n' +
         [...moduleConflicts, ...componentConflicts].join('\n'),
@@ -364,9 +389,9 @@ function parseiOSAnnotations(libraries) {
   return map;
 }
 
-function getLibraryName(library) {
+function getLibraryName(library /*: $FlowFixMe */) {
   return JSON.parse(
-    fs.readFileSync(path.join(library.libraryPath, 'package.json')),
+    fs.readFileSync(path.join(library.libraryPath, 'package.json'), 'utf8'),
   ).name;
 }
 
@@ -375,7 +400,10 @@ function getLibraryName(library) {
  *
  * This is needed when selectively disabling libraries in react-native.config.js since codegen should exclude those libraries as well.
  */
-function findDisabledLibrariesByPlatform(reactNativeConfig, platform) {
+function findDisabledLibrariesByPlatform(
+  reactNativeConfig /*: $FlowFixMe */,
+  platform /*: string */,
+) /*: Array<$FlowFixMe> */ {
   const dependencies = reactNativeConfig.dependencies ?? {};
 
   return Object.keys(dependencies).filter(

package/scripts/codegen/generate-specs-cli-executor.js

@@ -4,6 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
+ * @flow strict-local
  * @format
  */
 
@@ -14,22 +15,26 @@ const fs = require('fs');
 const path = require('path');
 
 const GENERATORS = {
-  all: {
-    android: ['componentsAndroid', 'modulesAndroid', 'modulesCxx'],
-    ios: ['componentsIOS', 'modulesIOS', 'modulesCxx'],
-  },
-  components: {
-    android: ['componentsAndroid'],
-    ios: ['componentsIOS'],
-  },
-  modules: {
-    android: ['modulesAndroid', 'modulesCxx'],
-    ios: ['modulesIOS', 'modulesCxx'],
-  },
-};
+    all: {
+      android: ['componentsAndroid', 'modulesAndroid', 'modulesCxx'],
+      ios: ['componentsIOS', 'modulesIOS', 'modulesCxx'],
+    },
+    components: {
+      android: ['componentsAndroid'],
+      ios: ['componentsIOS'],
+    },
+    modules: {
+      android: ['modulesAndroid', 'modulesCxx'],
+      ios: ['modulesIOS', 'modulesCxx'],
+    },
+  } /*:: as {[string]: {[string]: $ReadOnlyArray<string>}} */;
 
-function createOutputDirectoryIfNeeded(outputDirectory, libraryName) {
+function createOutputDirectoryIfNeeded(
+  outputDirectory /*: string */,
+  libraryName /*: string */,
+) {
   if (!outputDirectory) {
+    // $FlowFixMe[reassign-const]
     outputDirectory = path.resolve(__dirname, '..', 'Libraries', libraryName);
   }
   fs.mkdirSync(outputDirectory, {recursive: true});
@@ -43,7 +48,7 @@ function createOutputDirectoryIfNeeded(outputDirectory, libraryName) {
  * @return a valid schema
  * @throw an Error if the schema doesn't exists in a given path or if it can't be parsed.
  */
-function readAndParseSchema(schemaPath) {
+function readAndParseSchema(schemaPath /*: string */) {
   const schemaText = fs.readFileSync(schemaPath, 'utf-8');
 
   if (schemaText == null) {
@@ -57,20 +62,20 @@ function readAndParseSchema(schemaPath) {
   }
 }
 
-function validateLibraryType(libraryType) {
+function validateLibraryType(libraryType /*: string */) {
   if (GENERATORS[libraryType] == null) {
     throw new Error(`Invalid library type. ${libraryType}`);
   }
 }
 
 function generateSpecFromInMemorySchema(
-  platform,
-  schema,
-  outputDirectory,
-  libraryName,
-  packageName,
-  libraryType,
-  useLocalIncludePaths,
+  platform /*: string */,
+  schema /*: string */,
+  outputDirectory /*: string */,
+  libraryName /*: string */,
+  packageName /*: string */,
+  libraryType /*: string */,
+  useLocalIncludePaths /*: boolean */,
 ) {
   validateLibraryType(libraryType);
   createOutputDirectoryIfNeeded(outputDirectory, libraryName);
@@ -105,13 +110,14 @@ function generateSpecFromInMemorySchema(
 }
 
 function generateSpec(
-  platform,
-  schemaPath,
-  outputDirectory,
-  libraryName,
-  packageName,
-  libraryType,
+  platform /*: string */,
+  schemaPath /*: string */,
+  outputDirectory /*: string */,
+  libraryName /*: string */,
+  packageName /*: string */,
+  libraryType /*: string */,
 ) {
+  // $FlowFixMe[incompatible-call]
   generateSpecFromInMemorySchema(
     platform,
     readAndParseSchema(schemaPath),
@@ -124,5 +130,5 @@ function generateSpec(
 
 module.exports = {
   execute: generateSpec,
-  generateSpecFromInMemorySchema: generateSpecFromInMemorySchema,
+  generateSpecFromInMemorySchema,
 };

package/scripts/codegen/templates/ReactCodegen.podspec.template

@@ -16,6 +16,9 @@ use_frameworks = ENV['USE_FRAMEWORKS'] != nil
 folly_compiler_flags = Helpers::Constants.folly_config[:compiler_flags]
 boost_compiler_flags = Helpers::Constants.boost_config[:compiler_flags]
 
+header_search_paths = []
+framework_search_paths = []
+
 header_search_paths = [
   "\"$(PODS_ROOT)/ReactNativeDependencies\"",
   "\"${PODS_ROOT}/Headers/Public/ReactCodegen/react/renderer/components\"",
@@ -24,7 +27,6 @@ header_search_paths = [
   "\"$(PODS_ROOT)/Headers/Private/Yoga\"",
   "\"$(PODS_TARGET_SRCROOT)\"",
 ]
-framework_search_paths = []
 
 if use_frameworks
   ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-Fabric", "React_Fabric", ["react/renderer/components/view/platform/cxx"])
@@ -40,7 +42,7 @@ if use_frameworks
     .each { |search_path|
       header_search_paths << "\"#{search_path}\""
     }
-end
+  end
 
 Pod::Spec.new do |s|
   s.name                = "ReactCodegen"
@@ -80,6 +82,7 @@ Pod::Spec.new do |s|
 
   depend_on_js_engine(s)
   add_rn_third_party_dependencies(s)
+  add_rncore_dependency(s)
 
   s.script_phases = {
     'name' => 'Generate Specs',

package/scripts/compose-source-maps.js

@@ -5,6 +5,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
+ * @flow strict-local
  * @format
  */
 
@@ -14,7 +15,7 @@ const fs = require('fs');
 const {composeSourceMaps} = require('metro-source-map');
 
 const argv = process.argv.slice(2);
-let outputPath;
+let outputPath /*: ?string */;
 for (let i = 0; i < argv.length; ) {
   if (argv[i] === '-o') {
     outputPath = argv[i + 1];
@@ -58,7 +59,7 @@ if (!argv.length) {
   const composedMapJSON = JSON.stringify(
     composeSourceMaps([packagerSourcemap, compilerSourcemap]),
   );
-  if (outputPath) {
+  if (outputPath != null) {
     fs.writeFileSync(outputPath, composedMapJSON, 'utf8');
   } else {
     process.stdout.write(composedMapJSON);

package/scripts/generate-codegen-artifacts.js

@@ -4,6 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
+ * @flow strict-local
  * @format
  */
 
@@ -33,4 +34,5 @@ const argv = yargs
   .usage('Usage: $0 -p [path to app] -t [target platform] -o [output path]')
   .demandOption(['p', 't']).argv;
 
+// $FlowFixMe[prop-missing]
 executor.execute(argv.path, argv.targetPlatform, argv.outputPath, argv.source);

package/scripts/generate-provider-cli.js

@@ -4,6 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
+ * @flow strict-local
  * @format
  */
 
@@ -34,11 +35,15 @@ const argv = yargs
   ).argv;
 
 const GENERATORS = {
-  android: [],
-  ios: ['providerIOS'],
-};
+    android: [],
+    ios: ['providerIOS'],
+  } /*:: as {[string]: $ReadOnlyArray<string>} */;
 
-function generateProvider(platform, schemaListPath, outputDirectory) {
+function generateProvider(
+  platform /*: string */,
+  schemaListPath /*: string */,
+  outputDirectory /*: string */,
+) {
   const schemaListText = fs.readFileSync(schemaListPath, 'utf-8');
 
   if (schemaListText == null) {
@@ -57,7 +62,7 @@ function generateProvider(platform, schemaListPath, outputDirectory) {
     throw new Error(`Can't parse schema to JSON. ${schemaListPath}`);
   }
 
-  const schemas = {};
+  const schemas = {} /*:: as {[string]: $FlowFixMe} */;
   try {
     for (const libraryName of Object.keys(schemaPaths)) {
       const tmpSchemaText = fs.readFileSync(schemaPaths[libraryName], 'utf-8');
@@ -83,6 +88,7 @@ function generateProvider(platform, schemaListPath, outputDirectory) {
 }
 
 function main() {
+  // $FlowFixMe[prop-missing]
   generateProvider(argv.platform, argv.schemaListPath, argv.outputDir);
 }
 

package/scripts/generate-specs-cli.js

@@ -4,6 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
+ * @flow strict-local
  * @format
  */
 
@@ -49,11 +50,17 @@ const argv = yargs
 
 function main() {
   executor.execute(
+    // $FlowFixMe[prop-missing]
     argv.platform,
+    // $FlowFixMe[prop-missing]
     argv.schemaPath,
+    // $FlowFixMe[prop-missing]
     argv.outputDir,
+    // $FlowFixMe[prop-missing]
     argv.libraryName,
+    // $FlowFixMe[prop-missing]
     argv.javaPackageName,
+    // $FlowFixMe[prop-missing]
     argv.libraryType,
   );
 }

package/scripts/hermes/hermes-utils.js

@@ -243,9 +243,9 @@ set_target_properties(native-hermesc PROPERTIES
 }
 
 function getHermesPrebuiltArtifactsTarballName(
-  buildType /*: string */,
+  buildType /*:: ?: string */,
 ) /*: string */ {
-  if (!buildType) {
+  if (buildType == null) {
     throw Error('Did not specify build type.');
   }
   return `hermes-ios-${buildType.toLowerCase()}.tar.gz`;

package/scripts/hermes/prepare-hermes-for-build.js

@@ -4,6 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
+ * @flow strict-local
  * @format
  */
 
@@ -24,7 +25,7 @@ const {
   shouldUsePrebuiltHermesC,
 } = require('./hermes-utils');
 
-async function main(isInCI) {
+async function main(isInCI /*: boolean */) {
   if (!shouldBuildHermesFromSource(isInCI)) {
     copyPodSpec();
     return;