expo-modules-autolinking 3.0.0 → 3.0.2

package/src/index.ts

@@ -1,293 +1,25 @@
 import commander from 'commander';
-import path from 'path';
 
-import {
-  findModulesAsync,
-  generateModulesProviderAsync,
-  generatePackageListAsync,
-  getConfiguration,
-  getProjectPackageJsonPathAsync,
-  mergeLinkingOptionsAsync,
-  resolveExtraBuildDependenciesAsync,
-  resolveModulesAsync,
-  verifySearchResults,
-} from './autolinking';
-import {
-  makeCachedDependenciesLinker,
-  mergeResolutionResults,
-  scanDependencyResolutionsForPlatform,
-} from './dependencies';
-import { type RNConfigCommandOptions, createReactNativeConfigAsync } from './reactNativeConfig';
-import type {
-  ModuleDescriptor,
-  CommonNativeModuleDescriptor,
-  GenerateModulesProviderOptions,
-  GenerateOptions,
-  ResolveOptions,
-  SearchOptions,
-  SearchResults,
-  ModuleDescriptorAndroid,
-  ModuleDescriptorIos,
-} from './types';
+import { generateModulesProviderCommand } from './commands/generateModulesProviderCommand';
+import { generatePackageListCommand } from './commands/generatePackageListCommand';
+import { reactNativeConfigCommand } from './commands/reactNativeConfigCommand';
+import { resolveCommand } from './commands/resolveCommand';
+import { searchCommand } from './commands/searchCommand';
+import { verifyCommand } from './commands/verifyCommand';
 
-function hasCoreFeatures(
-  module: ModuleDescriptor
-): module is ModuleDescriptorAndroid | ModuleDescriptorIos {
-  return (module as CommonNativeModuleDescriptor).coreFeatures !== undefined;
-}
-
-/**
- * Registers a command that only searches for available expo modules.
- */
-function registerSearchCommand<OptionsType extends SearchOptions>(
-  commandName: string,
-  fn: (search: SearchResults, options: OptionsType) => any
-) {
-  return commander
-    .command(`${commandName} [paths...]`)
-    .option<string[] | null>(
-      '-i, --ignore-paths <ignorePaths...>',
-      'Paths to ignore when looking up for modules.',
-      (value, previous) => (previous ?? []).concat(value)
-    )
-    .option<string[] | null>(
-      '-e, --exclude <exclude...>',
-      'Package names to exclude when looking up for modules.',
-      (value, previous) => (previous ?? []).concat(value)
-    )
-    .option(
-      '-p, --platform [platform]',
-      'The platform that the resulting modules must support. Available options: "apple", "android"',
-      'apple'
-    )
-    .option('--silent', 'Silence resolution warnings')
-    .addOption(
-      new commander.Option(
-        '--project-root <projectRoot>',
-        'The path to the root of the project'
-      ).default(process.cwd(), 'process.cwd()')
-    )
-    .option(
-      '--only-project-deps',
-      'For a monorepo, include only modules that are the project dependencies.',
-      true
-    )
-    .option('--no-only-project-deps', 'Opposite of --only-project-deps', false)
-    .action(async (searchPaths, providedOptions) => {
-      const options = await mergeLinkingOptionsAsync<OptionsType>(
-        searchPaths.length > 0
-          ? {
-              ...providedOptions,
-              searchPaths,
-            }
-          : providedOptions
-      );
-      const searchResults = await findModulesAsync(options);
-      return await fn(searchResults, options);
-    });
-}
-
-/**
- * Registers a command that searches for modules and then resolves them for specific platform.
- */
-function registerResolveCommand<OptionsType extends ResolveOptions>(
-  commandName: string,
-  fn: (search: SearchResults, options: OptionsType) => any
-) {
-  return registerSearchCommand<OptionsType>(commandName, fn);
-}
+async function main(args: string[]) {
+  const cli = commander
+    .version(require('expo-modules-autolinking/package.json').version)
+    .description('CLI command that searches for native modules to autolink them.');
 
-/**
- * Registry the `react-native-config` command.
- */
-function registerReactNativeConfigCommand() {
-  return commander
-    .command('react-native-config [paths...]')
-    .option(
-      '-p, --platform [platform]',
-      'The platform that the resulting modules must support. Available options: "android", "ios"',
-      'ios'
-    )
-    .addOption(
-      new commander.Option(
-        '--project-root <projectRoot>',
-        'The path to the root of the project'
-      ).default(process.cwd(), 'process.cwd()')
-    )
-    .option('--source-dir <sourceDir>', 'The path to the native source directory')
-    .option<boolean>('-j, --json', 'Output results in the plain JSON format.', () => true, false)
-    .action(async (searchPaths, providedOptions) => {
-      if (!['android', 'ios'].includes(providedOptions.platform)) {
-        throw new Error(`Unsupported platform: ${providedOptions.platform}`);
-      }
-      const projectRoot = path.dirname(
-        await getProjectPackageJsonPathAsync(providedOptions.projectRoot)
-      );
-      const options = await mergeLinkingOptionsAsync<RNConfigCommandOptions>(
-        searchPaths.length > 0
-          ? {
-              ...providedOptions,
-              projectRoot,
-              searchPaths,
-            }
-          : {
-              ...providedOptions,
-              projectRoot,
-            }
-      );
-      const results = await createReactNativeConfigAsync(options);
-      if (providedOptions.json) {
-        console.log(JSON.stringify(results));
-      } else {
-        console.log(require('util').inspect(results, false, null, true));
-      }
-    });
-}
+  verifyCommand(cli);
+  searchCommand(cli);
+  resolveCommand(cli);
+  generatePackageListCommand(cli);
+  generateModulesProviderCommand(cli);
+  reactNativeConfigCommand(cli);
 
-/**
- Register the `verify` command.
- */
-function registerVerifyCommand() {
-  return commander
-    .command('verify')
-    .option(
-      '-p, --platform [platform]',
-      'The platform to validate native modules for. Available options: "android", "ios", "both"',
-      'both'
-    )
-    .addOption(
-      new commander.Option(
-        '--project-root <projectRoot>',
-        'The path to the root of the project'
-      ).default(process.cwd(), 'process.cwd()')
-    )
-    .option<boolean>(
-      '-v, --verbose',
-      'Output all results instead of just warnings.',
-      () => true,
-      false
-    )
-    .option<boolean>('-j, --json', 'Output results in the plain JSON format.', () => true, false)
-    .action(async (providedOptions) => {
-      const platforms =
-        providedOptions.platform === 'both' ? ['android', 'ios'] : [providedOptions.platform];
-      const linker = makeCachedDependenciesLinker({ projectRoot: providedOptions.projectRoot });
-      const results = mergeResolutionResults(
-        await Promise.all(
-          platforms.map((platform) => scanDependencyResolutionsForPlatform(linker, platform))
-        )
-      );
-      await verifySearchResults(results, {
-        projectRoot: providedOptions.projectRoot,
-        verbose: providedOptions.verbose,
-        json: providedOptions.json,
-      });
-    });
+  await cli.parseAsync(args, { from: 'user' });
 }
 
-module.exports = async function (args: string[]) {
-  // Searches for available expo modules.
-  registerSearchCommand<SearchOptions & { json?: boolean }>('search', async (results, options) => {
-    if (options.json) {
-      console.log(JSON.stringify(results));
-    } else {
-      console.log(require('util').inspect(results, false, null, true));
-    }
-  }).option<boolean>('-j, --json', 'Output results in the plain JSON format.', () => true, false);
-
-  // Checks whether there are no resolving issues in the current setup.
-  registerVerifyCommand();
-
-  // Searches for available expo modules and resolves the results for given platform.
-  registerResolveCommand('resolve', async (results, options) => {
-    const modules = await resolveModulesAsync(results, options);
-    const extraDependencies = await resolveExtraBuildDependenciesAsync(options);
-    const configuration = getConfiguration(options);
-
-    const coreFeatures = [
-      ...modules.reduce<Set<string>>((acc, module) => {
-        if (hasCoreFeatures(module)) {
-          const features = module.coreFeatures ?? [];
-          for (const feature of features) {
-            acc.add(feature);
-          }
-          return acc;
-        }
-
-        return acc;
-      }, new Set()),
-    ];
-    if (options.json) {
-      console.log(
-        JSON.stringify({
-          extraDependencies,
-          coreFeatures,
-          modules,
-          ...(configuration ? { configuration } : {}),
-        })
-      );
-    } else {
-      console.log(
-        require('util').inspect(
-          {
-            extraDependencies,
-            coreFeatures,
-            modules,
-            ...(configuration ? { configuration } : {}),
-          },
-          false,
-          null,
-          true
-        )
-      );
-    }
-  }).option<boolean>('-j, --json', 'Output results in the plain JSON format.', () => true, false);
-
-  // Generates a source file listing all packages to link.
-  // It's deprecated for apple platforms, use `generate-modules-provider` instead.
-  registerResolveCommand<GenerateOptions>('generate-package-list', async (results, options) => {
-    const modules = options.empty ? [] : await resolveModulesAsync(results, options);
-    generatePackageListAsync(modules, options);
-  })
-    .option(
-      '-t, --target <path>',
-      'Path to the target file, where the package list should be written to.'
-    )
-    .option(
-      '-n, --namespace <namespace>',
-      'Java package name under which the package list should be placed.'
-    )
-    .option(
-      '--empty',
-      'Whether to only generate an empty list. Might be used when the user opts-out of autolinking.',
-      false
-    );
-
-  // Generates a source file listing all packages to link in the runtime.
-  registerResolveCommand<GenerateModulesProviderOptions>(
-    'generate-modules-provider',
-    async (results, options) => {
-      const packages = options.packages ?? [];
-      const modules = await resolveModulesAsync(results, options);
-      const filteredModules = modules.filter((module) => packages.includes(module.packageName));
-
-      generateModulesProviderAsync(filteredModules, options);
-    }
-  )
-    .option(
-      '-t, --target <path>',
-      'Path to the target file, where the package list should be written to.'
-    )
-    .option('--entitlement <path>', 'Path to the Apple code signing entitlements file.')
-    .option(
-      '-p, --packages <packages...>',
-      'Names of the packages to include in the generated modules provider.'
-    );
-
-  registerReactNativeConfigCommand();
-
-  await commander
-    .version(require('expo-modules-autolinking/package.json').version)
-    .description('CLI command that searches for Expo modules to autolink them.')
-    .parseAsync(args, { from: 'user' });
-};
+module.exports = main;

package/src/platforms/{android.ts → android/android.ts}

@@ -2,22 +2,20 @@ import fs from 'fs';
 import { glob } from 'glob';
 import path from 'path';
 
-import type {
-  ExtraDependencies,
-  ModuleDescriptorAndroid,
-  PackageRevision,
-  ResolveOptions,
-} from '../types';
+import { AutolinkingOptions } from '../../commands/autolinkingOptions';
+import type { ExtraDependencies, ModuleDescriptorAndroid, PackageRevision } from '../../types';
 
 const ANDROID_PROPERTIES_FILE = 'gradle.properties';
 const ANDROID_EXTRA_BUILD_DEPS_KEY = 'android.extraMavenRepos';
 
-export function getConfiguration(options: ResolveOptions): Record<string, any> | undefined {
-  const buildFromSource = options.android?.buildFromSource;
-  if (buildFromSource) {
-    return { buildFromSource };
-  }
-  return undefined;
+interface AndroidConfigurationOutput {
+  buildFromSource: string[];
+}
+
+export function getConfiguration(
+  options: AutolinkingOptions
+): AndroidConfigurationOutput | undefined {
+  return options.buildFromSource ? { buildFromSource: options.buildFromSource } : undefined;
 }
 
 /**

package/src/platforms/android/index.ts

@@ -0,0 +1,6 @@
+export {
+  getConfiguration,
+  generatePackageListAsync,
+  resolveModuleAsync,
+  resolveExtraBuildDependenciesAsync,
+} from './android';

package/src/platforms/{apple.ts → apple/apple.ts}

@@ -3,15 +3,14 @@ import fs from 'fs';
 import { glob } from 'glob';
 import path from 'path';
 
-import { fileExistsAsync } from '../fileUtils';
+import { fileExistsAsync } from '../../fileUtils';
 import type {
   AppleCodeSignEntitlements,
   ExtraDependencies,
   ModuleDescriptorIos,
   ModuleIosPodspecInfo,
   PackageRevision,
-  SearchOptions,
-} from '../types';
+} from '../../types';
 
 const APPLE_PROPERTIES_FILE = 'Podfile.properties.json';
 const APPLE_EXTRA_BUILD_DEPS_KEY = 'apple.extraPods';
@@ -43,13 +42,11 @@ export function getSwiftModuleNames(
   return pods.map((pod) => pod.podName.replace(/[^a-zA-Z0-9]/g, '_'));
 }
 
-/**
- * Resolves module search result with additional details required for iOS platform.
- */
+/** Resolves module search result with additional details required for iOS platform. */
 export async function resolveModuleAsync(
   packageName: string,
   revision: PackageRevision,
-  options: SearchOptions
+  extraOutput: { flags?: Record<string, any> }
 ): Promise<ModuleDescriptorIos | null> {
   const podspecFiles = await findPodspecFiles(revision);
   if (!podspecFiles.length) {
@@ -68,7 +65,7 @@ export async function resolveModuleAsync(
     packageName,
     pods,
     swiftModuleNames,
-    flags: options.flags,
+    flags: extraOutput.flags,
     modules: revision.config?.appleModules() ?? [],
     appDelegateSubscribers: revision.config?.appleAppDelegateSubscribers() ?? [],
     reactDelegateHandlers: revision.config?.appleReactDelegateHandlers() ?? [],
@@ -99,7 +96,7 @@ export async function resolveExtraBuildDependenciesAsync(
 export async function generateModulesProviderAsync(
   modules: ModuleDescriptorIos[],
   targetPath: string,
-  entitlementPath: string
+  entitlementPath: string | null
 ): Promise<void> {
   const className = path.basename(targetPath, path.extname(targetPath));
   const entitlements = await parseEntitlementsAsync(entitlementPath);
@@ -280,8 +277,10 @@ function wrapInDebugConfigurationCheck(
   )}${debugBlock}\n${indent.repeat(indentationLevel)}#endif`;
 }
 
-async function parseEntitlementsAsync(entitlementPath: string): Promise<AppleCodeSignEntitlements> {
-  if (!(await fileExistsAsync(entitlementPath))) {
+async function parseEntitlementsAsync(
+  entitlementPath: string | null
+): Promise<AppleCodeSignEntitlements> {
+  if (!entitlementPath || !(await fileExistsAsync(entitlementPath))) {
     return {};
   }
   const { stdout } = await spawnAsync('plutil', ['-convert', 'json', '-o', '-', entitlementPath]);

package/src/platforms/apple/index.ts

@@ -0,0 +1,5 @@
+export {
+  generateModulesProviderAsync,
+  resolveModuleAsync,
+  resolveExtraBuildDependenciesAsync,
+} from './apple';

package/src/platforms/index.ts

@@ -0,0 +1,49 @@
+import { SupportedPlatform } from '../types';
+
+interface PlatformImplementations {
+  ios: typeof import('./apple/apple');
+  macos: typeof import('./apple/apple');
+  tvos: typeof import('./apple/apple');
+  apple: typeof import('./apple/apple');
+  android: typeof import('./android/android');
+  devtools: typeof import('./devtools');
+}
+
+function getLinkingImplementationForPlatform<Platform extends keyof PlatformImplementations>(
+  platform: Platform
+): PlatformImplementations[Platform];
+function getLinkingImplementationForPlatform(
+  platform: 'ios' | 'macos' | 'tvos' | 'apple'
+): PlatformImplementations['apple'];
+function getLinkingImplementationForPlatform(
+  platform: 'android'
+): PlatformImplementations['android'];
+function getLinkingImplementationForPlatform(
+  platform: 'devtools'
+): PlatformImplementations['devtools'];
+function getLinkingImplementationForPlatform(
+  platform: SupportedPlatform
+): PlatformImplementations[keyof PlatformImplementations];
+
+function getLinkingImplementationForPlatform(
+  platform: SupportedPlatform
+): PlatformImplementations[keyof PlatformImplementations] {
+  if (!platform) {
+    throw new Error(`No platform was specified, but linking commands require a specific platform.`);
+  }
+  switch (platform) {
+    case 'ios':
+    case 'macos':
+    case 'tvos':
+    case 'apple':
+      return require('../platforms/apple');
+    case 'android':
+      return require('../platforms/android');
+    case 'devtools':
+      return require('../platforms/devtools');
+    default:
+      throw new Error(`No linking implementation is available for platform "${platform}"`);
+  }
+}
+
+export { getLinkingImplementationForPlatform };

package/src/reactNativeConfig/reactNativeConfig.ts

@@ -1,7 +1,6 @@
-import fs from 'fs';
 import path from 'path';
 
-import type { SearchOptions, SupportedPlatform } from '../types';
+import type { SupportedPlatform } from '../types';
 import {
   findGradleAndManifestAsync,
   parsePackageNameAsync,
@@ -10,7 +9,6 @@ import {
 import { loadConfigAsync } from './config';
 import { resolveDependencyConfigImplIosAsync } from './iosResolver';
 import type {
-  RNConfigCommandOptions,
   RNConfigDependency,
   RNConfigDependencyAndroid,
   RNConfigDependencyIos,
@@ -20,7 +18,7 @@ import type {
   RNConfigResult,
 } from './reactNativeConfig.types';
 import { discoverExpoModuleConfigAsync, ExpoModuleConfig } from '../ExpoModuleConfig';
-import { mergeLinkingOptionsAsync } from '../autolinking';
+import { AutolinkingOptions } from '../commands/autolinkingOptions';
 import {
   DependencyResolution,
   filterMapResolutionResult,
@@ -96,49 +94,47 @@ export async function resolveReactNativeModule(
   );
 }
 
+interface CreateRNConfigParams {
+  appRoot: string;
+  sourceDir: string | undefined;
+  autolinkingOptions: AutolinkingOptions & { platform: SupportedPlatform };
+}
+
 /**
  * Create config for react-native core autolinking.
  */
-export async function createReactNativeConfigAsync(
-  providedOptions: RNConfigCommandOptions
-): Promise<RNConfigResult> {
-  const options = await mergeLinkingOptionsAsync<SearchOptions & RNConfigCommandOptions>(
-    providedOptions
-  );
-  const excludeNames = new Set(options.exclude);
-  const projectConfig = await loadConfigAsync<RNConfigReactNativeProjectConfig>(
-    options.projectRoot
-  );
+export async function createReactNativeConfigAsync({
+  appRoot,
+  sourceDir,
+  autolinkingOptions,
+}: CreateRNConfigParams): Promise<RNConfigResult> {
+  const excludeNames = new Set(autolinkingOptions.exclude);
+  const projectConfig = await loadConfigAsync<RNConfigReactNativeProjectConfig>(appRoot);
 
   // custom native modules should be resolved first so that they can override other modules
-  const searchPaths =
-    options.nativeModulesDir && fs.existsSync(options.nativeModulesDir)
-      ? [options.nativeModulesDir, ...(options.searchPaths ?? [])]
-      : (options.searchPaths ?? []);
+  const searchPaths = autolinkingOptions.nativeModulesDir
+    ? [autolinkingOptions.nativeModulesDir, ...autolinkingOptions.searchPaths]
+    : autolinkingOptions.searchPaths;
 
-  const limitDepth = options.legacy_shallowReactNativeLinking ? 1 : undefined;
+  const limitDepth = autolinkingOptions.legacy_shallowReactNativeLinking ? 1 : undefined;
 
   const resolutions = mergeResolutionResults(
     await Promise.all([
-      scanDependenciesFromRNProjectConfig(options.projectRoot, projectConfig),
+      scanDependenciesFromRNProjectConfig(appRoot, projectConfig),
       ...searchPaths.map((searchPath) => scanDependenciesInSearchPath(searchPath)),
-      scanDependenciesRecursively(options.projectRoot, { limitDepth }),
+      scanDependenciesRecursively(appRoot, { limitDepth }),
     ])
   );
 
   const dependencies = await filterMapResolutionResult(resolutions, (resolution) =>
-    resolveReactNativeModule(resolution, projectConfig, options.platform, excludeNames)
+    resolveReactNativeModule(resolution, projectConfig, autolinkingOptions.platform, excludeNames)
   );
 
   return {
-    root: options.projectRoot,
+    root: appRoot,
     reactNativePath: resolutions['react-native']?.path!,
     dependencies,
-    project: await resolveAppProjectConfigAsync(
-      options.projectRoot,
-      options.platform,
-      options.sourceDir
-    ),
+    project: await resolveAppProjectConfigAsync(appRoot, autolinkingOptions.platform, sourceDir),
   };
 }
 
@@ -147,6 +143,7 @@ export async function resolveAppProjectConfigAsync(
   platform: SupportedPlatform,
   sourceDir?: string
 ): Promise<RNConfigReactNativeAppProjectConfig> {
+  // TODO(@kitten): use the commandRoot here to find these files in non <projectRoot>/<platform> folders
   if (platform === 'android') {
     const androidDir = path.join(projectRoot, 'android');
     const { gradle, manifest } = await findGradleAndManifestAsync({ androidDir, isLibrary: false });

package/src/reactNativeConfig/reactNativeConfig.types.ts

@@ -1,31 +1,6 @@
 import type { SupportedPlatform } from '../types';
 
-/**
- * Options for 'react-native-config' command.
- */
-export interface RNConfigCommandOptions {
-  platform: SupportedPlatform;
-  projectRoot: string;
-  searchPaths?: string[];
-  transitiveLinkingDependencies: string[];
-  sourceDir?: string;
-  // NOTE(@kitten): This was missing before. The options utils are very imprecisely defined. Sometimes some options
-  // are defined but not used, and in this case this was missing
-  nativeModulesDir?: string | null;
-  /** Only scan direct "dependencies" of a project for React Native modules, rather than including transitive dependencies.
-   * @remarks
-   * Before SDK 54, React Native modules would only be linked if they were listed as dependencies
-   * of a project. However, in SDK 54+ transitive React Native modules dependencies are also
-   * auto-linked, unless this flag is enabled.
-   * @privateRemarks
-   * This is not an argument, but can only be specified on `expo.autolinking`
-   */
-  legacy_shallowReactNativeLinking?: boolean;
-}
-
-/**
- * Dependency configuration for Android platform.
- */
+/** Dependency configuration for Android platform. */
 export interface RNConfigDependencyAndroid {
   sourceDir: string;
   packageImportPath: string | null;
@@ -41,9 +16,7 @@ export interface RNConfigDependencyAndroid {
   isPureCxxDependency?: boolean;
 }
 
-/**
- * Dependency configuration for iOS platform.
- */
+/** Dependency configuration for iOS platform. */
 export interface RNConfigDependencyIos {
   podspecPath: string;
   version: string;
@@ -51,9 +24,7 @@ export interface RNConfigDependencyIos {
   scriptPhases: any[];
 }
 
-/**
- * Dependency configuration.
- */
+/** Dependency configuration. */
 export interface RNConfigDependency {
   root: string;
   name: string;
@@ -63,9 +34,7 @@ export interface RNConfigDependency {
   };
 }
 
-/**
- * Result of 'react-native-config' command.
- */
+/** Result of 'react-native-config' command. */
 export interface RNConfigResult {
   root: string;
   reactNativePath: string;