react-native-tvos 0.79.2-0 → 0.80.0-0

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

@@ -0,0 +1,80 @@
+/**
+ * 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 path = require('path');
+
+const REACT_NATIVE_REPOSITORY_ROOT = path.join(
+  __dirname,
+  '..',
+  '..',
+  '..',
+  '..',
+  '..',
+);
+
+const REACT_NATIVE_PACKAGE_ROOT_FOLDER = path.join(__dirname, '..', '..', '..');
+const CODEGEN_REPO_PATH = `${REACT_NATIVE_REPOSITORY_ROOT}/packages/react-native-codegen`;
+
+const RNCORE_CONFIGS = {
+  ios: path.join(REACT_NATIVE_PACKAGE_ROOT_FOLDER, 'ReactCommon'),
+  android: path.join(
+    REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+    'ReactAndroid',
+    'build',
+    'generated',
+    'source',
+    'codegen',
+  ),
+};
+
+const CORE_LIBRARIES_WITH_OUTPUT_FOLDER = {
+  rncore: RNCORE_CONFIGS,
+  FBReactNativeSpec: {
+    ios: path.join(
+      REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+      'React',
+      'FBReactNativeSpec',
+    ),
+    android: path.join(
+      REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+      'ReactAndroid',
+      'build',
+      'generated',
+      'source',
+      'codegen',
+    ),
+  },
+};
+
+const packageJsonPath = path.join(
+  REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+  'package.json',
+);
+
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath));
+const REACT_NATIVE = packageJson.name;
+
+const TEMPLATES_FOLDER_PATH = path.join(
+  REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+  'scripts',
+  'codegen',
+  'templates',
+);
+
+module.exports = {
+  CODEGEN_REPO_PATH,
+  CORE_LIBRARIES_WITH_OUTPUT_FOLDER,
+  REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+  REACT_NATIVE,
+  TEMPLATES_FOLDER_PATH,
+  packageJson,
+};

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

@@ -0,0 +1,66 @@
+/**
+ * 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 {TEMPLATES_FOLDER_PATH, packageJson} = require('./constants');
+const {codegenLog} = require('./utils');
+const fs = require('fs');
+const path = require('path');
+
+const APP_DEPENDENCY_PROVIDER_H_TEMPLATE_PATH = path.join(
+  TEMPLATES_FOLDER_PATH,
+  'RCTAppDependencyProviderH.template',
+);
+
+const APP_DEPENDENCY_PROVIDER_MM_TEMPLATE_PATH = path.join(
+  TEMPLATES_FOLDER_PATH,
+  'RCTAppDependencyProviderMM.template',
+);
+
+const APP_DEPENDENCY_PROVIDER_PODSPEC_TEMPLATE_PATH = path.join(
+  TEMPLATES_FOLDER_PATH,
+  'ReactAppDependencyProvider.podspec.template',
+);
+
+function generateAppDependencyProvider(outputDir) {
+  fs.mkdirSync(outputDir, {recursive: true});
+  codegenLog('Generating RCTAppDependencyProvider');
+
+  const templateH = fs.readFileSync(
+    APP_DEPENDENCY_PROVIDER_H_TEMPLATE_PATH,
+    'utf8',
+  );
+  const finalPathH = path.join(outputDir, 'RCTAppDependencyProvider.h');
+  fs.writeFileSync(finalPathH, templateH);
+  codegenLog(`Generated artifact: ${finalPathH}`);
+
+  const templateMM = fs.readFileSync(
+    APP_DEPENDENCY_PROVIDER_MM_TEMPLATE_PATH,
+    'utf8',
+  );
+  const finalPathMM = path.join(outputDir, 'RCTAppDependencyProvider.mm');
+  fs.writeFileSync(finalPathMM, templateMM);
+  codegenLog(`Generated artifact: ${finalPathMM}`);
+
+  // Generate the podspec file
+  const templatePodspec = fs
+    .readFileSync(APP_DEPENDENCY_PROVIDER_PODSPEC_TEMPLATE_PATH, 'utf8')
+    .replace(/{react-native-version}/, packageJson.version)
+    .replace(/{react-native-licence}/, packageJson.license);
+  const finalPathPodspec = path.join(
+    outputDir,
+    'ReactAppDependencyProvider.podspec',
+  );
+  fs.writeFileSync(finalPathPodspec, templatePodspec);
+  codegenLog(`Generated podspec: ${finalPathPodspec}`);
+}
+
+module.exports = {
+  generateAppDependencyProvider,
+};

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

@@ -0,0 +1,116 @@
+/**
+ * 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 {TEMPLATES_FOLDER_PATH} = require('./constants');
+const {parseiOSAnnotations} = require('./utils');
+const fs = require('fs');
+const path = require('path');
+const MODULES_PROTOCOLS_H_TEMPLATE_PATH = path.join(
+  TEMPLATES_FOLDER_PATH,
+  'RCTModulesConformingToProtocolsProviderH.template',
+);
+
+const MODULES_PROTOCOLS_MM_TEMPLATE_PATH = path.join(
+  TEMPLATES_FOLDER_PATH,
+  'RCTModulesConformingToProtocolsProviderMM.template',
+);
+
+function generateCustomURLHandlers(libraries, outputDir) {
+  const iosAnnotations = parseiOSAnnotations(libraries);
+
+  const imageURLLoaderModules = new Set();
+  const imageDataDecoderModules = new Set();
+  const urlRequestHandlersModules = new Set();
+
+  const wrapInArrayIfNecessary = value =>
+    Array.isArray(value) || value == null ? value : [value];
+  // Old API
+  for (const library of libraries) {
+    const modulesConformingToProtocol =
+      library?.config?.ios?.modulesConformingToProtocol;
+    if (modulesConformingToProtocol == null) {
+      continue;
+    }
+
+    wrapInArrayIfNecessary(
+      modulesConformingToProtocol.RCTImageURLLoader,
+    )?.forEach(moduleName => {
+      imageURLLoaderModules.add(moduleName);
+    });
+    wrapInArrayIfNecessary(
+      modulesConformingToProtocol.RCTImageDataDecoder,
+    )?.forEach(moduleName => {
+      imageDataDecoderModules.add(moduleName);
+    });
+    wrapInArrayIfNecessary(
+      modulesConformingToProtocol.RCTURLRequestHandler,
+    )?.forEach(moduleName => {
+      urlRequestHandlersModules.add(moduleName);
+    });
+  }
+
+  // New API
+  for (const {modules: moduleAnnotationMap} of Object.values(iosAnnotations)) {
+    for (const [moduleName, annotation] of Object.entries(
+      moduleAnnotationMap,
+    )) {
+      const conformsToProtocols = annotation.conformsToProtocols;
+      if (!conformsToProtocols) {
+        continue;
+      }
+
+      if (conformsToProtocols.includes('RCTImageURLLoader')) {
+        imageURLLoaderModules.add(moduleName);
+      }
+      if (conformsToProtocols.includes('RCTImageDataDecoder')) {
+        imageDataDecoderModules.add(moduleName);
+      }
+      if (conformsToProtocols.includes('RCTURLRequestHandler')) {
+        urlRequestHandlersModules.add(moduleName);
+      }
+    }
+  }
+
+  const customImageURLLoaderClasses = Array.from(imageURLLoaderModules)
+    .map(className => `@"${className}"`)
+    .join(',\n\t\t');
+
+  const customImageDataDecoderClasses = Array.from(imageDataDecoderModules)
+    .map(className => `@"${className}"`)
+    .join(',\n\t\t');
+
+  const customURLHandlerClasses = Array.from(urlRequestHandlersModules)
+    .map(className => `@"${className}"`)
+    .join(',\n\t\t');
+
+  const template = fs.readFileSync(MODULES_PROTOCOLS_MM_TEMPLATE_PATH, 'utf8');
+  const finalMMFile = template
+    .replace(/{imageURLLoaderClassNames}/, customImageURLLoaderClasses)
+    .replace(/{imageDataDecoderClassNames}/, customImageDataDecoderClasses)
+    .replace(/{requestHandlersClassNames}/, customURLHandlerClasses);
+
+  fs.mkdirSync(outputDir, {recursive: true});
+
+  fs.writeFileSync(
+    path.join(outputDir, 'RCTModulesConformingToProtocolsProvider.mm'),
+    finalMMFile,
+  );
+
+  const templateH = fs.readFileSync(MODULES_PROTOCOLS_H_TEMPLATE_PATH, 'utf8');
+  fs.writeFileSync(
+    path.join(outputDir, 'RCTModulesConformingToProtocolsProvider.h'),
+    templateH,
+  );
+}
+
+module.exports = {
+  generateCustomURLHandlers,
+};

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

@@ -0,0 +1,39 @@
+/**
+ * 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 {generateCode} = require('./generateNativeCode');
+const {generateSchemaInfo} = require('./generateSchemaInfos');
+const {
+  buildCodegenIfNeeded,
+  findProjectRootLibraries,
+  readPkgJsonInDirectory,
+} = require('./utils');
+
+function generateFBReactNativeSpecIOS(projectRoot /*: string */) /*: void*/ {
+  const ios = 'ios';
+  buildCodegenIfNeeded();
+  const pkgJson = readPkgJsonInDirectory(projectRoot);
+  const fbReactNativeSpecLib = findProjectRootLibraries(
+    pkgJson,
+    projectRoot,
+  ).filter(library => library.config.name === 'FBReactNativeSpec')[0];
+  if (!fbReactNativeSpecLib) {
+    throw new Error(
+      "[Codegen] Can't find FBReactNativeSpec library. Failed to generate rncore artifacts",
+    );
+  }
+  const fbReactNativeSchemaInfo = generateSchemaInfo(fbReactNativeSpecLib, ios);
+  generateCode('', fbReactNativeSchemaInfo, false, ios);
+}
+
+module.exports = {
+  generateFBReactNativeSpecIOS,
+};

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

@@ -0,0 +1,114 @@
+/**
+ * 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 generateSpecsCLIExecutor = require('../generate-specs-cli-executor');
+const {CORE_LIBRARIES_WITH_OUTPUT_FOLDER} = require('./constants');
+const {codegenLog} = require('./utils');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function generateNativeCode(
+  outputPath,
+  schemaInfos,
+  includesGeneratedCode,
+  platform,
+) {
+  return schemaInfos.map(schemaInfo => {
+    generateCode(outputPath, schemaInfo, includesGeneratedCode, platform);
+  });
+}
+
+function generateCode(outputPath, schemaInfo, includesGeneratedCode, platform) {
+  if (shouldSkipGenerationForRncore(schemaInfo, platform)) {
+    codegenLog(
+      '[Codegen - rncore] Skipping iOS code generation for rncore as it has been generated already.',
+      true,
+    );
+    return;
+  }
+
+  if (shouldSkipGenerationForFBReactNativeSpec(schemaInfo, platform)) {
+    codegenLog(
+      '[Codegen - FBReactNativeSpec] Skipping iOS code generation for FBReactNativeSpec as it has been generated already.',
+      true,
+    );
+    return;
+  }
+
+  const libraryName = schemaInfo.library.config.name;
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), libraryName));
+  const tmpOutputDir = path.join(tmpDir, 'out');
+  fs.mkdirSync(tmpOutputDir, {recursive: true});
+
+  codegenLog(`Generating Native Code for ${libraryName} - ${platform}`);
+  const useLocalIncludePaths = includesGeneratedCode;
+  generateSpecsCLIExecutor.generateSpecFromInMemorySchema(
+    platform,
+    schemaInfo.schema,
+    tmpOutputDir,
+    libraryName,
+    'com.facebook.fbreact.specs',
+    schemaInfo.library.config.type,
+    useLocalIncludePaths,
+  );
+
+  // Finally, copy artifacts to the final output directory.
+  const outputDir =
+    reactNativeCoreLibraryOutputPath(libraryName, platform) ?? outputPath;
+  fs.mkdirSync(outputDir, {recursive: true});
+  fs.cpSync(tmpOutputDir, outputDir, {recursive: true});
+  codegenLog(`Generated artifacts: ${outputDir}`);
+}
+
+function shouldSkipGenerationForRncore(schemaInfo, platform) {
+  if (platform !== 'ios' || schemaInfo.library.config.name !== 'rncore') {
+    return false;
+  }
+  const rncoreOutputPath = CORE_LIBRARIES_WITH_OUTPUT_FOLDER.rncore.ios;
+  const rncoreAbsolutePath = path.resolve(rncoreOutputPath);
+  return (
+    rncoreAbsolutePath.includes('node_modules') &&
+    fs.existsSync(rncoreAbsolutePath) &&
+    fs.readdirSync(rncoreAbsolutePath).length > 0
+  );
+}
+
+function reactNativeCoreLibraryOutputPath(libraryName, platform) {
+  return CORE_LIBRARIES_WITH_OUTPUT_FOLDER[libraryName]
+    ? CORE_LIBRARIES_WITH_OUTPUT_FOLDER[libraryName][platform]
+    : null;
+}
+
+function shouldSkipGenerationForFBReactNativeSpec(schemaInfo, platform) {
+  if (
+    platform !== 'ios' ||
+    schemaInfo.library.config.name !== 'FBReactNativeSpec'
+  ) {
+    return false;
+  }
+
+  const fbReactNativeSpecOutputPath =
+    CORE_LIBRARIES_WITH_OUTPUT_FOLDER.FBReactNativeSpec.ios;
+  const fbReactNativeSpecAbsolutePath = path.resolve(
+    fbReactNativeSpecOutputPath,
+  );
+  return (
+    fbReactNativeSpecAbsolutePath.includes('node_modules') &&
+    fs.existsSync(fbReactNativeSpecAbsolutePath) &&
+    fs.readdirSync(fbReactNativeSpecAbsolutePath).length > 0
+  );
+}
+
+module.exports = {
+  generateNativeCode,
+  generateCode,
+};

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

@@ -0,0 +1,120 @@
+/**
+ * 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 {TEMPLATES_FOLDER_PATH} = require('./constants');
+const {
+  codegenLog,
+  isReactNativeCoreLibrary,
+  parseiOSAnnotations,
+} = require('./utils');
+const fs = require('fs');
+const path = require('path');
+
+const MODULE_PROVIDERS_H_TEMPLATE_PATH = path.join(
+  TEMPLATES_FOLDER_PATH,
+  'RCTModuleProvidersH.template',
+);
+
+const MODULE_PROVIDERS_MM_TEMPLATE_PATH = path.join(
+  TEMPLATES_FOLDER_PATH,
+  'RCTModuleProvidersMM.template',
+);
+
+function generateRCTModuleProviders(
+  projectRoot,
+  pkgJson,
+  libraries,
+  outputDir,
+) {
+  fs.mkdirSync(outputDir, {recursive: true});
+  // Generate Header File
+  codegenLog('Generating RCTModulesProvider.h');
+  const templateH = fs.readFileSync(MODULE_PROVIDERS_H_TEMPLATE_PATH, 'utf8');
+  const finalPathH = path.join(outputDir, 'RCTModuleProviders.h');
+  fs.writeFileSync(finalPathH, templateH);
+  codegenLog(`Generated artifact: ${finalPathH}`);
+
+  codegenLog('Generating RCTModuleProviders.mm');
+  let modulesInLibraries = {};
+
+  let app = pkgJson.codegenConfig
+    ? {config: pkgJson.codegenConfig, libraryPath: projectRoot}
+    : null;
+
+  const moduleLibraries = libraries
+    .concat(app)
+    .filter(Boolean)
+    .filter(({config, libraryPath}) => {
+      if (
+        isReactNativeCoreLibrary(config.name) ||
+        config.type === 'components'
+      ) {
+        return false;
+      }
+      return true;
+    });
+
+  // Old API
+  moduleLibraries.forEach(({config, libraryPath}) => {
+    const libraryName = JSON.parse(
+      fs.readFileSync(path.join(libraryPath, 'package.json')),
+    ).name;
+
+    if (config.ios?.modulesProvider) {
+      modulesInLibraries[libraryName] = Object.keys(
+        config.ios?.modulesProvider,
+      ).map(moduleName => {
+        return {
+          moduleName,
+          className: config.ios?.modulesProvider[moduleName],
+        };
+      });
+    }
+  });
+
+  // New API
+  const iosAnnotations = parseiOSAnnotations(moduleLibraries);
+  for (const [libraryName, {modules: moduleAnnotationMap}] of Object.entries(
+    iosAnnotations,
+  )) {
+    for (const [moduleName, annotation] of Object.entries(
+      moduleAnnotationMap,
+    )) {
+      if (annotation.className) {
+        modulesInLibraries[libraryName] = modulesInLibraries[libraryName] || [];
+        modulesInLibraries[libraryName].push({
+          moduleName,
+          className: annotation.className,
+        });
+      }
+    }
+  }
+
+  const modulesMapping = Object.keys(modulesInLibraries)
+    .flatMap(library => {
+      const modules = modulesInLibraries[library];
+      return modules.map(({moduleName, className}) => {
+        return `\t\t@"${moduleName}": @"${className}", // ${library}`;
+      });
+    })
+    .join('\n');
+
+  // Generate implementation file
+  const templateMM = fs
+    .readFileSync(MODULE_PROVIDERS_MM_TEMPLATE_PATH, 'utf8')
+    .replace(/{moduleMapping}/, modulesMapping);
+  const finalPathMM = path.join(outputDir, 'RCTModuleProviders.mm');
+  fs.writeFileSync(finalPathMM, templateMM);
+  codegenLog(`Generated artifact: ${finalPathMM}`);
+}
+
+module.exports = {
+  generateRCTModuleProviders,
+};