react-native-tvos 0.76.6-0 → 0.77.0-0

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

@@ -21,7 +21,6 @@ const generateSpecsCLIExecutor = require('./generate-specs-cli-executor');
 const {execSync} = require('child_process');
 const fs = require('fs');
 const glob = require('glob');
-const mkdirp = require('mkdirp');
 const os = require('os');
 const path = require('path');
 
@@ -48,7 +47,11 @@ const RNCORE_CONFIGS = {
 const CORE_LIBRARIES_WITH_OUTPUT_FOLDER = {
   rncore: RNCORE_CONFIGS,
   FBReactNativeSpec: {
-    ios: null,
+    ios: path.join(
+      REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+      'React',
+      'FBReactNativeSpec',
+    ),
     android: path.join(
       REACT_NATIVE_PACKAGE_ROOT_FOLDER,
       'ReactAndroid',
@@ -59,7 +62,13 @@ const CORE_LIBRARIES_WITH_OUTPUT_FOLDER = {
     ),
   },
 };
-const REACT_NATIVE = 'react-native';
+
+const packageJsonPath = path.join(
+  REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+  'package.json',
+);
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath));
+const REACT_NATIVE = packageJson.name;
 
 const MODULES_PROTOCOLS_H_TEMPLATE_PATH = path.join(
   REACT_NATIVE_PACKAGE_ROOT_FOLDER,
@@ -77,6 +86,57 @@ const MODULES_PROTOCOLS_MM_TEMPLATE_PATH = path.join(
   'RCTModulesConformingToProtocolsProviderMM.template',
 );
 
+const THIRD_PARTY_COMPONENTS_H_TEMPLATE_PATH = path.join(
+  REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+  'scripts',
+  'codegen',
+  'templates',
+  'RCTThirdPartyComponentsProviderH.template',
+);
+
+const THIRD_PARTY_COMPONENTS_MM_TEMPLATE_PATH = path.join(
+  REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+  'scripts',
+  'codegen',
+  'templates',
+  'RCTThirdPartyComponentsProviderMM.template',
+);
+
+const APP_DEPENDENCY_PROVIDER_H_TEMPLATE_PATH = path.join(
+  REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+  'scripts',
+  'codegen',
+  'templates',
+  'RCTAppDependencyProviderH.template',
+);
+
+const APP_DEPENDENCY_PROVIDER_MM_TEMPLATE_PATH = path.join(
+  REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+  'scripts',
+  'codegen',
+  'templates',
+  'RCTAppDependencyProviderMM.template',
+);
+
+const APP_DEPENDENCY_PROVIDER_PODSPEC_TEMPLATE_PATH = path.join(
+  REACT_NATIVE_PACKAGE_ROOT_FOLDER,
+  'scripts',
+  'codegen',
+  'templates',
+  'ReactAppDependencyProvider.podspec.template',
+);
+
+const codegenLog = (text, info = false) => {
+  // ANSI escape codes for colors and formatting
+  const reset = '\x1b[0m';
+  const cyan = '\x1b[36m';
+  const yellow = '\x1b[33m';
+  const bold = '\x1b[1m';
+
+  const color = info ? yellow : '';
+  console.log(`${cyan}${bold}[Codegen]${reset} ${color}${text}${reset}`);
+};
+
 // HELPERS
 
 function pkgJsonIncludesGeneratedCode(pkgJson) {
@@ -99,11 +159,11 @@ function printDeprecationWarningIfNeeded(dependency) {
   if (dependency === REACT_NATIVE) {
     return;
   }
-  console.log(`[Codegen] CodegenConfig Deprecated Setup for ${dependency}.
+  codegenLog(`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:
+  codegenLog(`BEFORE:
     {
       // ...
       "codegenConfig": {
@@ -147,12 +207,11 @@ function extractLibrariesFromJSON(configFile, dependencyPath) {
   if (configFile.codegenConfig == null) {
     return [];
   }
-  console.log(`[Codegen] Found ${configFile.name}`);
+  codegenLog(`Found ${configFile.name}`);
   if (configFile.codegenConfig.libraries == null) {
     const config = configFile.codegenConfig;
     return [
       {
-        libraryName: configFile.name,
         config,
         libraryPath: dependencyPath,
       },
@@ -174,7 +233,7 @@ function getCocoaPodsPlatformKey(platformName) {
 }
 
 function extractSupportedApplePlatforms(dependency, dependencyPath) {
-  console.log('[Codegen] Searching for podspec in the project dependencies.');
+  codegenLog('Searching for podspec in the project dependencies.', true);
   const podspecs = glob.sync('*.podspec', {cwd: dependencyPath});
 
   if (podspecs.length === 0) {
@@ -216,8 +275,8 @@ function extractSupportedApplePlatforms(dependency, dependencyPath) {
   );
 
   if (supportedPlatformsList.length > 0) {
-    console.log(
-      `[Codegen] Supported Apple platforms: ${supportedPlatformsList.join(
+    codegenLog(
+      `Supported Apple platforms: ${supportedPlatformsList.join(
         ', ',
       )} for ${dependency}`,
     );
@@ -234,42 +293,52 @@ function findExternalLibraries(pkgJson, projectRoot) {
     'react-native-tvos': '*',
   };
   // Determine which of these are codegen-enabled libraries
-  console.log(
-    '[Codegen] Searching for codegen-enabled libraries in the project dependencies.',
+  codegenLog(
+    'Searching for codegen-enabled libraries in the project dependencies.',
+    true,
   );
   // Handle third-party libraries
   return Object.keys(dependencies).flatMap(dependency => {
+    let configFilePath = '';
     try {
-      const configFilePath = require.resolve(
-        path.join(dependency, 'package.json'),
-        {paths: [projectRoot]},
-      );
-      const configFile = JSON.parse(fs.readFileSync(configFilePath));
-      const codegenConfigFileDir = path.dirname(configFilePath);
-      return extractLibrariesFromJSON(configFile, codegenConfigFileDir);
+      configFilePath = require.resolve(path.join(dependency, 'package.json'), {
+        paths: [projectRoot],
+      });
     } catch (e) {
-      return [];
+      // require.resolve fails if the dependency is a local node module.
+      if (
+        dependencies[dependency].startsWith('.') || // handles relative paths
+        dependencies[dependency].startsWith('/') // handles absolute paths
+      ) {
+        configFilePath = path.join(
+          projectRoot,
+          pkgJson.dependencies[dependency],
+          'package.json',
+        );
+      } else {
+        return [];
+      }
     }
+    const configFile = JSON.parse(fs.readFileSync(configFilePath));
+    const codegenConfigFileDir = path.dirname(configFilePath);
+    return extractLibrariesFromJSON(configFile, codegenConfigFileDir);
   });
 }
 
-function readRNConfigJSFile(projectRoot) {
+function findLibrariesFromReactNativeConfig(projectRoot) {
   const rnConfigFileName = 'react-native.config.js';
 
+  codegenLog(
+    `Searching for codegen-enabled libraries in ${rnConfigFileName}`,
+    true,
+  );
+
   const rnConfigFilePath = path.resolve(projectRoot, rnConfigFileName);
 
   if (!fs.existsSync(rnConfigFilePath)) {
     return [];
   }
-  return require(rnConfigFilePath);
-}
-
-function findLibrariesFromReactNativeConfig(projectRoot) {
-  console.log(
-    `\n\n[Codegen] >>>>> Searching for codegen-enabled libraries in react-native.config.js`,
-  );
-
-  const rnConfig = readRNConfigJSFile(projectRoot);
+  const rnConfig = require(rnConfigFilePath);
 
   if (rnConfig.dependencies == null) {
     return [];
@@ -295,60 +364,19 @@ function findLibrariesFromReactNativeConfig(projectRoot) {
   });
 }
 
-// Function to look for libraries explicitly unlinked from the app
-// through the react-native.config.js file.
-// If this happens, it might be that the app does not need
-// to generate code for that library as it won't be used by that platform
-// @return { [libraryName: string]: [platform: string] }
-function findNotLinkedLibraries(projectRoot) {
-  const rnConfig = readRNConfigJSFile(projectRoot);
-
-  if (rnConfig.dependencies == null) {
-    return {};
-  }
-
-  let notLinkedLibraries = {};
-
-  Object.keys(rnConfig.dependencies).forEach(name => {
-    const dependency = rnConfig.dependencies[name];
-    let notLinkedPlatforms = [];
-
-    // dependency.platforms might not be defined, as the format
-    // {
-    //   "dependencies": {
-    //     "dependency-name": {
-    //       "root": "path/to/dependency",
-    //     }
-    //   }
-    // }
-    // is also supported.
-    // In this case, we assume that the library is linked to all platforms.
-    // We don't consider the case were `dependency-name.root` is equal to `null`, because that
-    // means that the library is not linked to the app at all, and in that case the dependency
-    // should be removed by the user.
-    dependency.platforms &&
-      Object.keys(dependency.platforms).forEach(platform => {
-        if (dependency.platforms[platform] == null) {
-          notLinkedPlatforms.push(platform);
-        }
-      });
-    notLinkedLibraries[name] = notLinkedPlatforms;
-  });
-  return notLinkedLibraries;
-}
-
 function findProjectRootLibraries(pkgJson, projectRoot) {
-  console.log('[Codegen] Searching for codegen-enabled libraries in the app.');
+  codegenLog('Searching for codegen-enabled libraries in the app.', true);
 
   if (pkgJson.codegenConfig == null) {
-    console.log(
-      '[Codegen] The "codegenConfig" field is not defined in package.json. Assuming there is nothing to generate at the app level.',
+    codegenLog(
+      'The "codegenConfig" field is not defined in package.json. Assuming there is nothing to generate at the app level.',
+      true,
     );
     return [];
   }
 
   if (typeof pkgJson.codegenConfig !== 'object') {
-    throw '[Codegen] The "codegenConfig" field must be an Object.';
+    throw 'The "codegenConfig" field must be an Object.';
   }
 
   return extractLibrariesFromJSON(pkgJson, projectRoot);
@@ -365,7 +393,7 @@ function buildCodegenIfNeeded() {
   if (fs.existsSync(libPath) && fs.readdirSync(libPath).length > 0) {
     return;
   }
-  console.log('[Codegen] Building react-native-codegen package.');
+  codegenLog('Building react-native-codegen package.', true);
   execSync('yarn install', {
     cwd: CODEGEN_REPO_PATH,
     stdio: 'inherit',
@@ -443,7 +471,7 @@ function generateSchemaInfo(library, platform) {
     library.libraryPath,
     library.config.jsSrcsDir,
   );
-  console.log(`[Codegen] Processing ${library.config.name}`);
+  codegenLog(`Processing ${library.config.name}`);
 
   const supportedApplePlatforms = extractSupportedApplePlatforms(
     library.config.name,
@@ -468,13 +496,7 @@ function shouldSkipGenerationForRncore(schemaInfo, platform) {
   if (platform !== 'ios' || schemaInfo.library.config.name !== 'rncore') {
     return false;
   }
-  const rncoreOutputPath = path.join(
-    RNCORE_CONFIGS.ios,
-    'react',
-    'renderer',
-    'components',
-    'rncore',
-  );
+  const rncoreOutputPath = CORE_LIBRARIES_WITH_OUTPUT_FOLDER.rncore.ios;
   const rncoreAbsolutePath = path.resolve(rncoreOutputPath);
   return (
     rncoreAbsolutePath.includes('node_modules') &&
@@ -483,10 +505,39 @@ function shouldSkipGenerationForRncore(schemaInfo, platform) {
   );
 }
 
+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
+  );
+}
+
 function generateCode(outputPath, schemaInfo, includesGeneratedCode, platform) {
   if (shouldSkipGenerationForRncore(schemaInfo, platform)) {
-    console.log(
+    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;
   }
@@ -496,9 +547,7 @@ function generateCode(outputPath, schemaInfo, includesGeneratedCode, platform) {
   const tmpOutputDir = path.join(tmpDir, 'out');
   fs.mkdirSync(tmpOutputDir, {recursive: true});
 
-  console.log(
-    `[Codegen] Generating Native Code for ${libraryName} - ${platform}`,
-  );
+  codegenLog(`Generating Native Code for ${libraryName} - ${platform}`);
   const useLocalIncludePaths = includesGeneratedCode;
   generateSpecsCLIExecutor.generateSpecFromInMemorySchema(
     platform,
@@ -515,7 +564,7 @@ function generateCode(outputPath, schemaInfo, includesGeneratedCode, platform) {
     reactNativeCoreLibraryOutputPath(libraryName, platform) ?? outputPath;
   fs.mkdirSync(outputDir, {recursive: true});
   fs.cpSync(tmpOutputDir, outputDir, {recursive: true});
-  console.log(`[Codegen] Generated artifacts: ${outputDir}`);
+  codegenLog(`Generated artifacts: ${outputDir}`);
 }
 
 function generateSchemaInfos(libraries) {
@@ -533,28 +582,6 @@ function generateNativeCode(
   });
 }
 
-function rootCodegenTargetNeedsThirdPartyComponentProvider(pkgJson, platform) {
-  return !pkgJsonIncludesGeneratedCode(pkgJson) && platform === 'ios';
-}
-
-function dependencyNeedsThirdPartyComponentProvider(
-  schemaInfo,
-  platform,
-  appCodegenConfigSpec,
-) {
-  // 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.
-  // We also have to filter out the the components defined in the app
-  // because the RCTThirdPartyComponentProvider is generated inside Fabric,
-  // which lives in a different target from the app and it has no visibility over
-  // the symbols defined in the app.
-  return (
-    !isReactNativeCoreLibrary(schemaInfo.library.config.name, platform) &&
-    schemaInfo.library.config.name !== appCodegenConfigSpec
-  );
-}
-
 function mustGenerateNativeCode(includeLibraryPath, schemaInfo) {
   // If library's 'codegenConfig' sets 'includesGeneratedCode' to 'true',
   // then we assume that native code is shipped with the library,
@@ -565,27 +592,6 @@ function mustGenerateNativeCode(includeLibraryPath, schemaInfo) {
   );
 }
 
-function createComponentProvider(schemas, supportedApplePlatforms) {
-  console.log('[Codegen] Creating component provider.');
-  const outputDir = path.join(
-    REACT_NATIVE_PACKAGE_ROOT_FOLDER,
-    'React',
-    'Fabric',
-  );
-  mkdirp.sync(outputDir);
-  utils.getCodegen().generateFromSchemas(
-    {
-      schemas: schemas,
-      outputDirectory: outputDir,
-      supportedApplePlatforms,
-    },
-    {
-      generators: ['providerIOS'],
-    },
-  );
-  console.log(`[Codegen] Generated provider in: ${outputDir}`);
-}
-
 function findCodegenEnabledLibraries(pkgJson, projectRoot) {
   const projectLibraries = findProjectRootLibraries(pkgJson, projectRoot);
   if (pkgJsonIncludesGeneratedCode(pkgJson)) {
@@ -633,6 +639,8 @@ function generateCustomURLHandlers(libraries, outputDir) {
     .replace(/{imageDataDecoderClassNames}/, customImageDataDecoderClasses)
     .replace(/{requestHandlersClassNames}/, customURLHandlerClasses);
 
+  fs.mkdirSync(outputDir, {recursive: true});
+
   fs.writeFileSync(
     path.join(outputDir, 'RCTModulesConformingToProtocolsProvider.mm'),
     finalMMFile,
@@ -645,6 +653,175 @@ function generateCustomURLHandlers(libraries, outputDir) {
   );
 }
 
+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}`);
+}
+
+function generateRCTThirdPartyComponents(libraries, outputDir) {
+  fs.mkdirSync(outputDir, {recursive: true});
+  // Generate Header File
+  codegenLog('Generating RCTThirdPartyComponentsProvider.h');
+  const templateH = fs.readFileSync(
+    THIRD_PARTY_COMPONENTS_H_TEMPLATE_PATH,
+    'utf8',
+  );
+  const finalPathH = path.join(outputDir, 'RCTThirdPartyComponentsProvider.h');
+  fs.writeFileSync(finalPathH, templateH);
+  codegenLog(`Generated artifact: ${finalPathH}`);
+
+  codegenLog('Generating RCTThirdPartyComponentsProvider.mm');
+  let componentsInLibraries = {};
+  libraries.forEach(({config, libraryPath}) => {
+    if (isReactNativeCoreLibrary(config.name) || config.type === 'modules') {
+      return;
+    }
+
+    const libraryName = JSON.parse(
+      fs.readFileSync(path.join(libraryPath, 'package.json')),
+    ).name;
+    if (config.ios?.componentProvider) {
+      componentsInLibraries[libraryName] = Object.keys(
+        config.ios?.componentProvider,
+      ).map(componentName => {
+        return {
+          componentName,
+          className: config.ios?.componentProvider[componentName],
+        };
+      });
+      return;
+    }
+    codegenLog(`Crawling ${libraryName} library for components`);
+    // crawl all files and subdirectories for file with the ".mm" extension
+    const files = findFilesWithExtension(libraryPath, '.mm');
+
+    const componentsMapping = files
+      .flatMap(file => findRCTComponentViewProtocolClass(file))
+      .filter(Boolean);
+
+    if (componentsMapping.length !== 0) {
+      codegenLog(
+        `[DEPRECATED] ${libraryName} should add the 'ios.componentProvider' property in their codegenConfig`,
+        true,
+      );
+    }
+
+    componentsInLibraries[libraryName] = componentsMapping;
+  });
+
+  const thirdPartyComponentsMapping = Object.keys(componentsInLibraries)
+    .flatMap(library => {
+      const components = componentsInLibraries[library];
+      return components.map(({componentName, className}) => {
+        return `\t\t@"${componentName}": NSClassFromString(@"${className}"), // ${library}`;
+      });
+    })
+    .join('\n');
+  // Generate implementation file
+  const templateMM = fs
+    .readFileSync(THIRD_PARTY_COMPONENTS_MM_TEMPLATE_PATH, 'utf8')
+    .replace(/{thirdPartyComponentsMapping}/, thirdPartyComponentsMapping);
+  const finalPathMM = path.join(
+    outputDir,
+    'RCTThirdPartyComponentsProvider.mm',
+  );
+  fs.writeFileSync(finalPathMM, templateMM);
+  codegenLog(`Generated artifact: ${finalPathMM}`);
+}
+
+// Given a path, return the paths of all the files with extension .mm in
+// the path dir and all its subdirectories.
+function findFilesWithExtension(filePath, extension) {
+  const files = [];
+  const dir = fs.readdirSync(filePath);
+  dir.forEach(file => {
+    const absolutePath = path.join(filePath, file);
+    // Exclude files provided by react-native
+    if (absolutePath.includes(`${path.sep}react-native${path.sep}`)) {
+      return null;
+    }
+
+    // Skip hidden folders, that starts with `.`
+    if (absolutePath.includes(`${path.sep}.`)) {
+      return null;
+    }
+
+    if (
+      fs.existsSync(absolutePath) &&
+      fs.statSync(absolutePath).isDirectory()
+    ) {
+      files.push(...findFilesWithExtension(absolutePath, extension));
+    } else if (file.endsWith(extension)) {
+      files.push(absolutePath);
+    }
+  });
+  return files;
+}
+
+// Given a filepath, read the file and look for a string that starts with 'Class<RCTComponentViewProtocol> '
+// and ends with 'Cls(void)'. Return the string between the two.
+function findRCTComponentViewProtocolClass(filepath) {
+  const fileContent = fs.readFileSync(filepath, 'utf8');
+  const regex = /Class<RCTComponentViewProtocol> (.*)Cls\(/;
+  const match = fileContent.match(regex);
+  if (match) {
+    const componentName = match[1];
+
+    // split the file by \n
+    // remove all the lines before the one that matches the regex above
+    // find the first return statement after that that ends with .class
+    // return what's between return and `.class`
+    const lines = fileContent.split('\n');
+    const signatureIndex = lines.findIndex(line => regex.test(line));
+    const returnRegex = /return (.*)\.class/;
+    const classNameMatch = String(lines.slice(signatureIndex)).match(
+      returnRegex,
+    );
+    if (classNameMatch) {
+      const className = classNameMatch[1];
+      codegenLog(`Match found ${componentName} -> ${className}`);
+      return {
+        componentName,
+        className,
+      };
+    }
+
+    console.warn(
+      `Could not find class name for component ${componentName}. Register it manually`,
+    );
+    return null;
+  }
+  return null;
+}
+
 // It removes all the empty files and empty folders
 // it finds, starting from `filepath`, recursively.
 //
@@ -694,6 +871,23 @@ function generateRNCoreComponentsIOS(projectRoot /*: string */) /*: void*/ {
   generateCode('', rncoreSchemaInfo, false, ios);
 }
 
+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);
+}
+
 // Execute
 
 /**
@@ -712,9 +906,7 @@ function generateRNCoreComponentsIOS(projectRoot /*: string */) /*: void*/ {
  */
 function execute(projectRoot, targetPlatform, baseOutputPath) {
   try {
-    console.log(
-      `[Codegen] Analyzing ${path.join(projectRoot, 'package.json')}`,
-    );
+    codegenLog(`Analyzing ${path.join(projectRoot, 'package.json')}`);
 
     const supportedPlatforms = ['android', 'ios'];
     if (
@@ -735,15 +927,13 @@ function execute(projectRoot, targetPlatform, baseOutputPath) {
     const libraries = findCodegenEnabledLibraries(pkgJson, projectRoot);
 
     if (libraries.length === 0) {
-      console.log('[Codegen] No codegen-enabled libraries found.');
+      codegenLog('No codegen-enabled libraries found.', true);
       return;
     }
 
     let platforms =
       targetPlatform === 'all' ? supportedPlatforms : [targetPlatform];
 
-    const notLinkedLibraries = findNotLinkedLibraries(projectRoot);
-
     for (const platform of platforms) {
       const outputPath = computeOutputPath(
         projectRoot,
@@ -752,19 +942,7 @@ function execute(projectRoot, targetPlatform, baseOutputPath) {
         platform,
       );
 
-      const schemaInfos = generateSchemaInfos(
-        libraries.filter(library => {
-          const unlinkedPlatforms = notLinkedLibraries[library.libraryName];
-          if (unlinkedPlatforms && unlinkedPlatforms.includes(platform)) {
-            console.log(
-              `[Codegen - ${library.libraryName}] Skipping Codegen on ${platform}`,
-            );
-            return false;
-          }
-          return true;
-        }),
-      );
-
+      const schemaInfos = generateSchemaInfos(libraries);
       generateNativeCode(
         outputPath,
         schemaInfos.filter(schemaInfo =>
@@ -774,39 +952,25 @@ function execute(projectRoot, targetPlatform, baseOutputPath) {
         platform,
       );
 
-      if (
-        rootCodegenTargetNeedsThirdPartyComponentProvider(pkgJson, platform)
-      ) {
-        const filteredSchemas = schemaInfos.filter(schemaInfo =>
-          dependencyNeedsThirdPartyComponentProvider(
-            schemaInfo,
-            platform,
-            pkgJson.codegenConfig?.name,
-          ),
-        );
-        const schemas = filteredSchemas.map(schemaInfo => schemaInfo.schema);
-        const supportedApplePlatforms = filteredSchemas.map(
-          schemaInfo => schemaInfo.supportedApplePlatforms,
-        );
-
-        createComponentProvider(schemas, supportedApplePlatforms);
-        generateCustomURLHandlers(libraries, outputPath);
-      }
+      generateRCTThirdPartyComponents(libraries, outputPath);
+      generateCustomURLHandlers(libraries, outputPath);
+      generateAppDependencyProvider(outputPath);
 
       cleanupEmptyFilesAndFolders(outputPath);
     }
   } catch (err) {
-    console.error(err);
+    codegenLog(err);
     process.exitCode = 1;
   }
 
-  console.log('[Codegen] Done.');
+  codegenLog('Done.', true);
   return;
 }
 
 module.exports = {
   execute,
   generateRNCoreComponentsIOS,
+  generateFBReactNativeSpecIOS,
   // exported for testing purposes only:
   _extractLibrariesFromJSON: extractLibrariesFromJSON,
   _cleanupEmptyFilesAndFolders: cleanupEmptyFilesAndFolders,