expo-modules-autolinking 3.0.0 → 3.0.2

package/src/commands/resolveCommand.ts

@@ -0,0 +1,101 @@
+import commander from 'commander';
+
+import {
+  AutolinkingCommonArguments,
+  createAutolinkingOptionsLoader,
+  registerAutolinkingArguments,
+} from './autolinkingOptions';
+import { findModulesAsync } from '../autolinking/findModules';
+import { getConfiguration } from '../autolinking/getConfiguration';
+import {
+  resolveModulesAsync,
+  resolveExtraBuildDependenciesAsync,
+} from '../autolinking/resolveModules';
+import type {
+  ModuleDescriptor,
+  CommonNativeModuleDescriptor,
+  ModuleDescriptorAndroid,
+  ModuleDescriptorIos,
+} from '../types';
+
+function hasCoreFeatures(
+  module: ModuleDescriptor
+): module is ModuleDescriptorAndroid | ModuleDescriptorIos {
+  return (module as CommonNativeModuleDescriptor).coreFeatures !== undefined;
+}
+
+interface ResolveArguments extends AutolinkingCommonArguments {
+  json?: boolean | null;
+}
+
+/** Searches for available expo modules and resolves the results for given platform. */
+export function resolveCommand(cli: commander.CommanderStatic) {
+  return registerAutolinkingArguments(cli.command('resolve [searchPaths...]'))
+    .option('-j, --json', 'Output results in the plain JSON format.', () => true, false)
+    .action(async (searchPaths: string[] | null, commandArguments: ResolveArguments) => {
+      const platform = commandArguments.platform ?? 'apple';
+      const autolinkingOptionsLoader = createAutolinkingOptionsLoader({
+        ...commandArguments,
+        searchPaths,
+      });
+
+      const autolinkingOptions = await autolinkingOptionsLoader.getPlatformOptions(platform);
+      const appRoot = await autolinkingOptionsLoader.getAppRoot();
+
+      const expoModulesSearchResults = await findModulesAsync({
+        autolinkingOptions,
+        appRoot,
+      });
+
+      const expoModulesResolveResults = await resolveModulesAsync(
+        expoModulesSearchResults,
+        autolinkingOptions
+      );
+
+      const extraDependencies = await resolveExtraBuildDependenciesAsync({
+        commandRoot: autolinkingOptionsLoader.getCommandRoot(),
+        platform,
+      });
+
+      const configuration = getConfiguration({ autolinkingOptions });
+
+      const coreFeatures = [
+        ...expoModulesResolveResults.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 (commandArguments.json) {
+        console.log(
+          JSON.stringify({
+            extraDependencies,
+            coreFeatures,
+            modules: expoModulesResolveResults,
+            ...(configuration ? { configuration } : {}),
+          })
+        );
+      } else {
+        console.log(
+          require('util').inspect(
+            {
+              extraDependencies,
+              coreFeatures,
+              modules: expoModulesResolveResults,
+              ...(configuration ? { configuration } : {}),
+            },
+            false,
+            null,
+            true
+          )
+        );
+      }
+    });
+}

package/src/commands/searchCommand.ts

@@ -0,0 +1,35 @@
+import commander from 'commander';
+
+import {
+  AutolinkingCommonArguments,
+  createAutolinkingOptionsLoader,
+  registerAutolinkingArguments,
+} from './autolinkingOptions';
+import { findModulesAsync } from '../autolinking/findModules';
+
+interface SearchArguments extends AutolinkingCommonArguments {
+  json?: boolean | null;
+}
+
+export function searchCommand(cli: commander.CommanderStatic) {
+  return registerAutolinkingArguments(cli.command('search [searchPaths...]'))
+    .option('-j, --json', 'Output results in the plain JSON format.', () => true, false)
+    .action(async (searchPaths: string[] | null, commandArguments: SearchArguments) => {
+      const platform = commandArguments.platform ?? 'apple';
+      const autolinkingOptionsLoader = createAutolinkingOptionsLoader({
+        ...commandArguments,
+        searchPaths,
+      });
+
+      const expoModulesSearchResults = await findModulesAsync({
+        autolinkingOptions: await autolinkingOptionsLoader.getPlatformOptions(platform),
+        appRoot: await autolinkingOptionsLoader.getAppRoot(),
+      });
+
+      if (commandArguments.json) {
+        console.log(JSON.stringify(expoModulesSearchResults));
+      } else {
+        console.log(require('util').inspect(expoModulesSearchResults, false, null, true));
+      }
+    });
+}

package/src/{autolinking/verifySearchResults.ts → commands/verifyCommand.ts}

@@ -1,16 +1,58 @@
 import chalk from 'chalk';
+import commander from 'commander';
 import fs from 'fs';
 import path from 'path';
 
 import {
-  BaseDependencyResolution,
-  DependencyResolution,
+  AutolinkingCommonArguments,
+  createAutolinkingOptionsLoader,
+  registerAutolinkingArguments,
+} from './autolinkingOptions';
+import {
+  type BaseDependencyResolution,
+  type DependencyResolution,
+  type ResolutionResult,
   DependencyResolutionSource,
-  ResolutionResult,
+  makeCachedDependenciesLinker,
+  mergeResolutionResults,
+  scanDependencyResolutionsForPlatform,
 } from '../dependencies';
 
+interface VerifyArguments extends AutolinkingCommonArguments {
+  verbose?: boolean | null;
+  json?: boolean | null;
+}
+
+export function verifyCommand(cli: commander.CommanderStatic) {
+  return registerAutolinkingArguments(cli.command('verify'))
+    .option('-v, --verbose', 'Output all results instead of just warnings.', () => true, false)
+    .option('-j, --json', 'Output results in the plain JSON format.', () => true, false)
+    .option(
+      '-p, --platform [platform]',
+      'The platform to validate native modules for. Available options: "android", "ios", "both"',
+      'both'
+    )
+    .action(async (commandArguments: VerifyArguments) => {
+      const platforms =
+        commandArguments.platform === 'both' ? ['android', 'ios'] : [commandArguments.platform!];
+      const autolinkingOptionsLoader = createAutolinkingOptionsLoader(commandArguments);
+      const appRoot = await autolinkingOptionsLoader.getAppRoot();
+      const linker = makeCachedDependenciesLinker({ projectRoot: appRoot });
+      const results = mergeResolutionResults(
+        await Promise.all(
+          platforms.map((platform) => scanDependencyResolutionsForPlatform(linker, platform))
+        )
+      );
+      await verifySearchResults(results, {
+        appRoot,
+        verbose: !!commandArguments.verbose,
+        json: !!commandArguments.json,
+      });
+    });
+}
+
 interface VerifyOptions {
-  projectRoot: string;
+  appRoot: string;
   verbose?: boolean;
   json?: boolean;
 }
@@ -29,7 +71,7 @@ export async function verifySearchResults(
   results: ResolutionResult,
   options: VerifyOptions
 ): Promise<void> {
-  const { projectRoot } = options;
+  const { appRoot } = options;
 
   async function getHumanReadableDependency(dependency: BaseDependencyResolution): Promise<string> {
     let version = dependency.version || null;
@@ -47,7 +89,7 @@ export async function verifySearchResults(
         version = null;
       }
     }
-    const relative = path.relative(projectRoot, dependency.originPath);
+    const relative = path.relative(appRoot, dependency.originPath);
     return version
       ? `${dependency.name}@${version} (at: ${relative})`
       : `${dependency.name} at: ${relative}`;

package/src/dependencies/CachedDependenciesLinker.ts

@@ -1,13 +1,13 @@
 import fs from 'fs';
 
-import { SearchOptions, SupportedPlatform } from '../autolinking';
+import { PackageRevision, SupportedPlatform } from '../types';
 import { scanDependenciesRecursively } from './resolution';
 import { scanDependenciesFromRNProjectConfig } from './rncliLocal';
 import { scanDependenciesInSearchPath } from './scanning';
 import { type ResolutionResult, DependencyResolutionSource } from './types';
 import { filterMapResolutionResult, mergeResolutionResults } from './utils';
 import { resolveExpoModule } from '../autolinking/findModules';
-import { createLinkingOptionsFactory } from '../autolinking/mergeLinkingOptions';
+import { AutolinkingOptions, createAutolinkingOptionsLoader } from '../commands/autolinkingOptions';
 import { resolveReactNativeModule, RNConfigReactNativeProjectConfig } from '../reactNativeConfig';
 import { loadConfigAsync } from '../reactNativeConfig/config';
 
@@ -27,14 +27,12 @@ export interface CachedDependenciesLinker {
 export function makeCachedDependenciesLinker(params: {
   projectRoot: string;
 }): CachedDependenciesLinker {
-  const linkingOptionsFactory = createLinkingOptionsFactory<SearchOptions>({
+  const autolinkingOptionsLoader = createAutolinkingOptionsLoader({
     projectRoot: params.projectRoot,
-    platform: 'apple', // Placeholder value
   });
 
-  let projectRoot: Promise<string> | undefined;
-  const getProjectRoot = () =>
-    projectRoot || (projectRoot = linkingOptionsFactory.getProjectRoot());
+  let appRoot: Promise<string> | undefined;
+  const getAppRoot = () => appRoot || (appRoot = autolinkingOptionsLoader.getAppRoot());
 
   const dependenciesResultBySearchPath = new Map<string, Promise<ResolutionResult>>();
   let reactNativeProjectConfig: Promise<RNConfigReactNativeProjectConfig | null> | undefined;
@@ -43,13 +41,13 @@ export function makeCachedDependenciesLinker(params: {
 
   return {
     async getOptionsForPlatform(platform) {
-      const options = await linkingOptionsFactory.getPlatformOptions(platform);
+      const options = await autolinkingOptionsLoader.getPlatformOptions(platform);
       return makeCachedDependenciesSearchOptions(options);
     },
     async loadReactNativeProjectConfig() {
       if (reactNativeProjectConfig === undefined) {
         reactNativeProjectConfig = loadConfigAsync<RNConfigReactNativeProjectConfig>(
-          await getProjectRoot()
+          await getAppRoot()
         );
       }
       return reactNativeProjectConfig;
@@ -59,7 +57,7 @@ export function makeCachedDependenciesLinker(params: {
       return (
         reactNativeProjectConfigDependencies ||
         (reactNativeProjectConfigDependencies = scanDependenciesFromRNProjectConfig(
-          await getProjectRoot(),
+          await getAppRoot(),
           reactNativeProjectConfig
         ))
       );
@@ -67,7 +65,7 @@ export function makeCachedDependenciesLinker(params: {
     async scanDependenciesRecursively() {
       return (
         recursiveDependencies ||
-        (recursiveDependencies = scanDependenciesRecursively(await getProjectRoot()))
+        (recursiveDependencies = scanDependenciesRecursively(await getAppRoot()))
       );
     },
     async scanDependenciesInSearchPath(searchPath: string) {
@@ -134,7 +132,27 @@ export async function scanDependencyResolutionsForPlatform(
   return dependencies;
 }
 
-const makeCachedDependenciesSearchOptions = (options: SearchOptions) => ({
+export async function scanExpoModuleResolutionsForPlatform(
+  linker: CachedDependenciesLinker,
+  platform: SupportedPlatform
+): Promise<Record<string, PackageRevision>> {
+  const { excludeNames, searchPaths } = await linker.getOptionsForPlatform(platform);
+  const resolutions = mergeResolutionResults(
+    await Promise.all([
+      ...searchPaths.map((searchPath) => {
+        return linker.scanDependenciesInSearchPath(searchPath);
+      }),
+      linker.scanDependenciesRecursively(),
+    ])
+  );
+  return await filterMapResolutionResult(resolutions, async (resolution) => {
+    return !excludeNames.has(resolution.name)
+      ? await resolveExpoModule(resolution, platform, excludeNames)
+      : null;
+  });
+}
+
+const makeCachedDependenciesSearchOptions = (options: AutolinkingOptions) => ({
   excludeNames: new Set(options.exclude),
   searchPaths:
     options.nativeModulesDir && fs.existsSync(options.nativeModulesDir)

package/src/exports.ts

@@ -1,4 +1,18 @@
+import findUp from 'find-up';
+
+import { findModulesAsync } from './autolinking/findModules';
+import { resolveModulesAsync } from './autolinking/resolveModules';
+import {
+  AutolinkingCommonArguments,
+  AutolinkingOptions,
+  createAutolinkingOptionsLoader,
+  filterMapSearchPaths,
+} from './commands/autolinkingOptions';
+import { ModuleDescriptor, SupportedPlatform } from './types';
+
+export * from './types';
 export * from './autolinking';
+export * from './platforms';
 
 export {
   ResolutionResult,
@@ -9,4 +23,55 @@ export {
   CachedDependenciesSearchOptions,
   makeCachedDependenciesLinker,
   scanDependencyResolutionsForPlatform,
+  scanExpoModuleResolutionsForPlatform,
 } from './dependencies';
+
+/** @deprecated */
+export async function mergeLinkingOptionsAsync<Options extends Partial<AutolinkingCommonArguments>>(
+  argumentsOptions: Options
+): Promise<Options & AutolinkingOptions> {
+  const autolinkingOptionsLoader = createAutolinkingOptionsLoader(argumentsOptions);
+  return {
+    ...argumentsOptions,
+    ...(await autolinkingOptionsLoader.getPlatformOptions()),
+    projectRoot: autolinkingOptionsLoader.getAppRoot(),
+  };
+}
+
+interface QueryAutolinkingModulesFromProjectParams extends Partial<AutolinkingCommonArguments> {
+  platform: SupportedPlatform;
+  [extra: string]: unknown;
+}
+
+/** @deprecated */
+export async function queryAutolinkingModulesFromProjectAsync(
+  projectRoot: string,
+  options: QueryAutolinkingModulesFromProjectParams
+): Promise<ModuleDescriptor[]> {
+  const autolinkingOptionsLoader = createAutolinkingOptionsLoader({
+    ...options,
+    // NOTE(@kitten): This has always been duplicated
+    projectRoot: options.projectRoot ?? projectRoot,
+  });
+  const appRoot = await autolinkingOptionsLoader.getAppRoot();
+  const autolinkingOptions = await autolinkingOptionsLoader.getPlatformOptions(options.platform);
+  const searchResults = await findModulesAsync({ appRoot, autolinkingOptions });
+  return await resolveModulesAsync(searchResults, autolinkingOptions);
+}
+
+/** @deprecated */
+export function findProjectRootSync(cwd: string = process.cwd()): string {
+  const result = findUp.sync('package.json', { cwd });
+  if (!result) {
+    throw new Error(`Couldn't find "package.json" up from path "${cwd}"`);
+  }
+  return result;
+}
+
+/** @deprecated */
+export async function resolveSearchPathsAsync(
+  searchPaths: string[] | null,
+  cwd: string
+): Promise<string[]> {
+  return filterMapSearchPaths(searchPaths, cwd) ?? [];
+}