react-native-tvos 0.69.8-2 → 0.71.7-0rc0

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

@@ -0,0 +1,560 @@
+/**
+ * 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')));
+}
+
+function printDeprecationWarningIfNeeded(dependency) {
+  if (dependency === REACT_NATIVE_DEPENDENCY_NAME) {
+    return;
+  }
+  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": "."
+      }
+    }
+  `);
+}
+
+// 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 {
+    printDeprecationWarningIfNeeded(dependency);
+    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 handleLibrariesFromReactNativeConfig(
+  libraries,
+  codegenConfigKey,
+  codegenConfigFilename,
+  appRootDir,
+) {
+  const rnConfigFileName = 'react-native.config.js';
+
+  console.log(
+    `\n\n[Codegen] >>>>> Searching for codegen-enabled libraries in ${rnConfigFileName}`,
+  );
+
+  const rnConfigFilePath = path.resolve(appRootDir, rnConfigFileName);
+
+  if (fs.existsSync(rnConfigFilePath)) {
+    const rnConfig = require(rnConfigFilePath);
+
+    if (rnConfig.dependencies != null) {
+      Object.keys(rnConfig.dependencies).forEach(name => {
+        const dependencyConfig = rnConfig.dependencies[name];
+
+        if (dependencyConfig.root) {
+          const codegenConfigFileDir = path.resolve(
+            appRootDir,
+            dependencyConfig.root,
+          );
+          const configFilePath = path.join(
+            codegenConfigFileDir,
+            codegenConfigFilename,
+          );
+          const pkgJsonPath = path.join(codegenConfigFileDir, 'package.json');
+
+          if (fs.existsSync(configFilePath)) {
+            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath));
+            const configFile = JSON.parse(fs.readFileSync(configFilePath));
+            extractLibrariesFromJSON(
+              configFile,
+              libraries,
+              codegenConfigKey,
+              pkgJson.name,
+              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',
+    )} --platform ios ${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}`);
+  }
+}
+
+function findCodegenEnabledLibraries(
+  appRootDir,
+  baseCodegenConfigFileDir,
+  codegenConfigFilename,
+  codegenConfigKey,
+) {
+  const pkgJson = readPackageJSON(appRootDir);
+  const dependencies = {...pkgJson.dependencies, ...pkgJson.devDependencies};
+  const libraries = [];
+
+  handleReactNativeCodeLibraries(
+    libraries,
+    codegenConfigFilename,
+    codegenConfigKey,
+  );
+  handleThirdPartyLibraries(
+    libraries,
+    baseCodegenConfigFileDir,
+    dependencies,
+    codegenConfigFilename,
+    codegenConfigKey,
+  );
+  handleLibrariesFromReactNativeConfig(
+    libraries,
+    codegenConfigKey,
+    codegenConfigFilename,
+    appRootDir,
+  );
+  handleInAppLibraries(libraries, pkgJson, codegenConfigKey, appRootDir);
+
+  return libraries;
+}
+
+// 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 libraries = findCodegenEnabledLibraries(
+      appRootDir,
+      baseCodegenConfigFileDir,
+      codegenConfigFilename,
+      codegenConfigKey,
+    );
+
+    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,
+  _findCodegenEnabledLibraries: findCodegenEnabledLibraries,
+  _executeNodeScript: executeNodeScript,
+  _generateCode: generateCode,
+  _cleanupEmptyFilesAndFolders: cleanupEmptyFilesAndFolders,
+};

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

@@ -0,0 +1,127 @@
+/**
+ * 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';
+
+const fs = require('fs');
+const mkdirp = require('mkdirp');
+const path = require('path');
+const utils = require('./codegen-utils');
+const RNCodegen = utils.getCodegen();
+
+const GENERATORS = {
+  all: {
+    android: ['componentsAndroid', 'modulesAndroid', 'modulesCxx'],
+    ios: ['componentsIOS', 'modulesIOS', 'modulesCxx'],
+  },
+  components: {
+    android: ['componentsAndroid'],
+    ios: ['componentsIOS'],
+  },
+  modules: {
+    android: ['modulesAndroid', 'modulesCxx'],
+    ios: ['modulesIOS', 'modulesCxx'],
+  },
+};
+
+function createOutputDirectoryIfNeeded(outputDirectory, libraryName) {
+  if (!outputDirectory) {
+    outputDirectory = path.resolve(__dirname, '..', 'Libraries', libraryName);
+  }
+  mkdirp.sync(outputDirectory);
+}
+
+function createFolderIfDefined(folder) {
+  if (folder) {
+    mkdirp.sync(folder);
+  }
+}
+
+/**
+ * This function read a JSON schema from a path and parses it.
+ * It throws if the schema don't exists or it can't be parsed.
+ *
+ * @parameter schemaPath: the path to the schema
+ * @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) {
+  const schemaText = fs.readFileSync(schemaPath, 'utf-8');
+
+  if (schemaText == null) {
+    throw new Error(`Can't find schema at ${schemaPath}`);
+  }
+
+  try {
+    return JSON.parse(schemaText);
+  } catch (err) {
+    throw new Error(`Can't parse schema to JSON. ${schemaPath}`);
+  }
+}
+
+function validateLibraryType(libraryType) {
+  if (GENERATORS[libraryType] == null) {
+    throw new Error(`Invalid library type. ${libraryType}`);
+  }
+}
+
+function generateSpec(
+  platform,
+  schemaPath,
+  outputDirectory,
+  libraryName,
+  packageName,
+  libraryType,
+) {
+  validateLibraryType(libraryType);
+
+  let schema = readAndParseSchema(schemaPath);
+
+  createOutputDirectoryIfNeeded(outputDirectory, libraryName);
+  function composePath(intermediate) {
+    return path.join(outputDirectory, intermediate, libraryName);
+  }
+
+  // These are hardcoded and should not be changed.
+  // The codegen creates some C++ code with #include directive
+  // which uses these paths. Those directive are not customizable yet.
+  createFolderIfDefined(composePath('react/renderer/components/'));
+  createFolderIfDefined(composePath('./'));
+
+  RNCodegen.generate(
+    {
+      libraryName,
+      schema,
+      outputDirectory,
+      packageName,
+    },
+    {
+      generators: GENERATORS[libraryType][platform],
+    },
+  );
+
+  if (platform === 'android') {
+    // Move all components C++ files to a structured jni folder for now.
+    // Note: this should've been done by RNCodegen's generators, but:
+    // * the generators don't support platform option yet
+    // * this subdir structure is Android-only, not applicable to iOS
+    const files = fs.readdirSync(outputDirectory);
+    const jniOutputDirectory = `${outputDirectory}/jni/react/renderer/components/${libraryName}`;
+    mkdirp.sync(jniOutputDirectory);
+    files
+      .filter(f => f.endsWith('.h') || f.endsWith('.cpp'))
+      .forEach(f => {
+        fs.renameSync(`${outputDirectory}/${f}`, `${jniOutputDirectory}/${f}`);
+      });
+  }
+}
+
+module.exports = {
+  execute: generateSpec,
+};