expo-modules-autolinking 3.0.0 → 3.0.2

package/src/autolinking/index.ts

@@ -1,51 +1,58 @@
-import path from 'path';
-
+import { AutolinkingOptions, createAutolinkingOptionsLoader } from '../commands/autolinkingOptions';
+import { ExtraDependencies, ModuleDescriptor, SearchResults, SupportedPlatform } from '../types';
 import { findModulesAsync } from './findModules';
-import {
-  getProjectPackageJsonPathAsync,
-  getProjectPackageJsonPathSync,
-  mergeLinkingOptionsAsync,
-  resolveSearchPaths,
-} from './mergeLinkingOptions';
 import { resolveExtraBuildDependenciesAsync, resolveModulesAsync } from './resolveModules';
-import type { ModuleDescriptor, SearchOptions } from '../types';
-import { getConfiguration } from './getConfiguration';
 
-export {
-  findModulesAsync,
-  getProjectPackageJsonPathAsync,
-  mergeLinkingOptionsAsync,
-  resolveExtraBuildDependenciesAsync,
-  resolveModulesAsync,
-  getConfiguration,
-};
+export { getConfiguration } from './getConfiguration';
 export { generateModulesProviderAsync, generatePackageListAsync } from './generatePackageList';
-export { verifySearchResults } from './verifySearchResults';
-export * from '../types';
 
-export async function resolveSearchPathsAsync(
-  searchPaths: string[] | null,
-  cwd: string
-): Promise<string[]> {
-  return resolveSearchPaths(searchPaths, cwd);
+/** @deprecated */
+export interface SearchOptions extends Partial<AutolinkingOptions> {
+  projectRoot: string;
+  platform: SupportedPlatform;
+  [extra: string]: unknown;
 }
 
-/**
- * Programmatic API to query autolinked modules for a project.
- */
-export async function queryAutolinkingModulesFromProjectAsync(
-  projectRoot: string,
-  options: Pick<SearchOptions, 'platform' | 'exclude' | 'onlyProjectDeps'>
-): Promise<ModuleDescriptor[]> {
-  const searchPaths = await resolveSearchPathsAsync(null, projectRoot);
-  const linkOptions = await mergeLinkingOptionsAsync({ ...options, projectRoot, searchPaths });
-  const searchResults = await findModulesAsync(linkOptions);
-  return await resolveModulesAsync(searchResults, linkOptions);
+/** @deprecated */
+export interface ResolveOptions {
+  projectRoot: string;
+  platform: SupportedPlatform;
+  [extra: string]: unknown;
+}
+
+/** @deprecated */
+async function apiFindModulesAsync(providedOptions: SearchOptions): Promise<SearchResults> {
+  const autolinkingOptionsLoader = createAutolinkingOptionsLoader(providedOptions);
+  return findModulesAsync({
+    appRoot: await autolinkingOptionsLoader.getAppRoot(),
+    autolinkingOptions: await autolinkingOptionsLoader.getPlatformOptions(providedOptions.platform),
+  });
 }
 
-/**
- * Get the project root directory from the current working directory.
- */
-export function findProjectRootSync(cwd: string = process.cwd()): string {
-  return path.dirname(getProjectPackageJsonPathSync(cwd));
+/** @deprecated */
+async function apiResolveExtraBuildDependenciesAsync(
+  providedOptions: ResolveOptions
+): Promise<ExtraDependencies> {
+  return resolveExtraBuildDependenciesAsync({
+    commandRoot: providedOptions.projectRoot,
+    platform: providedOptions.platform,
+  });
 }
+
+/** @deprecated */
+async function apiResolveModulesAsync(
+  searchResults: SearchResults,
+  providedOptions: SearchOptions
+): Promise<ModuleDescriptor[]> {
+  const autolinkingOptionsLoader = createAutolinkingOptionsLoader(providedOptions);
+  return resolveModulesAsync(
+    searchResults,
+    await autolinkingOptionsLoader.getPlatformOptions(providedOptions.platform)
+  );
+}
+
+export {
+  apiFindModulesAsync as findModulesAsync,
+  apiResolveExtraBuildDependenciesAsync as resolveExtraBuildDependenciesAsync,
+  apiResolveModulesAsync as resolveModulesAsync,
+};

package/src/autolinking/resolveModules.ts

@@ -1,46 +1,59 @@
-import { getLinkingImplementationForPlatform } from './utils';
-import type { ExtraDependencies, ModuleDescriptor, ResolveOptions, SearchResults } from '../types';
+import { AutolinkingOptions } from '../commands/autolinkingOptions';
+import { getLinkingImplementationForPlatform } from '../platforms';
+import type {
+  ExtraDependencies,
+  ModuleDescriptor,
+  SearchResults,
+  SupportedPlatform,
+} from '../types';
 
-/**
- * Resolves search results to a list of platform-specific configuration.
- */
+/** Resolves search results to a list of platform-specific configuration. */
 export async function resolveModulesAsync(
   searchResults: SearchResults,
-  options: ResolveOptions
+  autolinkingOptions: AutolinkingOptions & { platform: SupportedPlatform }
 ): Promise<ModuleDescriptor[]> {
-  const platformLinking = getLinkingImplementationForPlatform(options.platform);
+  const platformLinking = getLinkingImplementationForPlatform(autolinkingOptions.platform);
+  // Additional output property for Cocoapods flags
+  const extraOutput = { flags: autolinkingOptions.flags };
 
-  return (
-    await Promise.all(
-      Object.entries(searchResults).map(async ([packageName, revision]) => {
-        const resolvedModule = await platformLinking.resolveModuleAsync(
-          packageName,
-          revision,
-          options
-        );
-        return resolvedModule
-          ? {
-              packageName,
-              packageVersion: revision.version,
-              ...resolvedModule,
-            }
-          : null;
-      })
-    )
-  )
-    .filter(Boolean)
+  const moduleDescriptorList = await Promise.all(
+    Object.entries(searchResults).map(async ([packageName, revision]) => {
+      const resolvedModule = await platformLinking.resolveModuleAsync(
+        packageName,
+        revision,
+        extraOutput
+      );
+      return resolvedModule
+        ? {
+            ...resolvedModule,
+            packageVersion: revision.version,
+            packageName: resolvedModule.packageName ?? packageName,
+          }
+        : null;
+    })
+  );
+
+  return moduleDescriptorList
+    .filter((moduleDescriptor) => moduleDescriptor != null)
     .sort((a, b) => a.packageName.localeCompare(b.packageName));
 }
 
-/**
- * Resolves the extra build dependencies for the project, such as additional Maven repositories or CocoaPods pods.
- */
-export async function resolveExtraBuildDependenciesAsync(
-  options: ResolveOptions
-): Promise<ExtraDependencies> {
-  const platformLinking = getLinkingImplementationForPlatform(options.platform);
+interface ResolveExtraBuildDependenciesParams {
+  commandRoot: string;
+  platform: SupportedPlatform;
+}
+
+/** Resolves the extra build dependencies for the project, such as additional Maven repositories or CocoaPods pods. */
+export async function resolveExtraBuildDependenciesAsync({
+  commandRoot,
+  platform,
+}: ResolveExtraBuildDependenciesParams): Promise<ExtraDependencies> {
+  const platformLinking = getLinkingImplementationForPlatform(platform);
   const extraDependencies = await platformLinking.resolveExtraBuildDependenciesAsync(
-    options.projectRoot
+    // NOTE: We assume we must be inside the native folder here
+    // The `resolve` command either is invoked in the CWD of `./{android,ios}` or has a `--project-root`
+    // that's in the native directory
+    commandRoot
   );
   return extraDependencies ?? [];
 }

package/src/commands/autolinkingOptions.ts

@@ -0,0 +1,265 @@
+import commander from 'commander';
+import findUp from 'find-up';
+import fs from 'fs';
+import path from 'path';
+
+import { SupportedPlatform } from '../types';
+
+export interface AutolinkingOptions {
+  /** 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.
+   * @defaultValue `false`
+   */
+  legacy_shallowReactNativeLinking: boolean;
+  /** Extra modules directories to search for native modules.
+   * @defaultValue `[]`
+   */
+  searchPaths: string[];
+  /** Local native modules directory to add to autolinking.
+   * @defaultValue `"./modules"`
+   */
+  nativeModulesDir: string | null;
+  /** Native modules to exclude from autolinking by name.
+   * @defaultValue `[]`
+   */
+  exclude: string[];
+  /** A list of package names to opt out of prebuilt Expo modules (Android-only)
+   * @defaultValue `[]`
+   */
+  buildFromSource?: string[];
+  /** CocoaPods flags to pass to each autolinked pod (Apple/iOS-only)
+   * @defaultValue `[]`
+   */
+  flags?: Record<string, any>;
+}
+
+const isJSONObject = (x: unknown): x is Record<string, unknown> =>
+  x != null && typeof x === 'object';
+
+const resolvePathMaybe = (target: unknown, basePath: string): string | null => {
+  if (typeof target !== 'string') {
+    return null;
+  }
+  let resolved = path.resolve(basePath, target);
+  if (fs.existsSync(resolved)) {
+    return resolved;
+  } else if ((resolved = path.resolve(target)) && fs.existsSync(target)) {
+    // TODO(@kitten): This is here for legacy support. However, this *will* be inconsistent
+    // This relies on the current working directory, and hence, can behave differently depending
+    // on where the command was invoked.
+    return target;
+  } else {
+    return null;
+  }
+};
+
+export const filterMapSearchPaths = (
+  searchPaths: unknown,
+  basePath: string
+): string[] | undefined => {
+  if (Array.isArray(searchPaths)) {
+    return searchPaths
+      .map((searchPath) => resolvePathMaybe(searchPath, basePath))
+      .filter((searchPath) => searchPath != null);
+  } else {
+    return undefined;
+  }
+};
+
+const parsePackageJsonOptions = (
+  packageJson: Record<string, unknown>,
+  appRoot: string,
+  platform: SupportedPlatform | null | undefined
+): Partial<AutolinkingOptions> => {
+  const expo = isJSONObject(packageJson.expo) ? packageJson.expo : null;
+  const autolinkingOptions = expo && isJSONObject(expo.autolinking) ? expo.autolinking : null;
+  let platformOptions: Record<string, unknown> | null = null;
+  if (platform) {
+    autolinkingOptions && isJSONObject(autolinkingOptions[platform])
+      ? autolinkingOptions[platform]
+      : null;
+    if (!platformOptions && platform === 'apple') {
+      // NOTE: `platform: 'apple'` has a fallback on `ios`. This doesn't make much sense, since apple should
+      // be the base option for other apple platforms, but changing this now is a breaking change
+      platformOptions =
+        autolinkingOptions && isJSONObject(autolinkingOptions.ios) ? autolinkingOptions.ios : null;
+    }
+  }
+  const mergedOptions = { ...autolinkingOptions, ...platformOptions };
+  const outputOptions: Partial<AutolinkingOptions> = {};
+  // legacy_shallowReactNativeLinking
+  if (mergedOptions.legacy_shallowReactNativeLinking != null) {
+    outputOptions.legacy_shallowReactNativeLinking =
+      !!mergedOptions.legacy_shallowReactNativeLinking;
+  }
+  // searchPaths
+  if (typeof mergedOptions.searchPaths === 'string' || Array.isArray(mergedOptions.searchPaths)) {
+    const rawSearchPaths =
+      typeof mergedOptions.searchPaths === 'string'
+        ? [mergedOptions.searchPaths]
+        : mergedOptions.searchPaths;
+    outputOptions.searchPaths = filterMapSearchPaths(rawSearchPaths, appRoot);
+  }
+  // nativeModulesDir
+  if (typeof mergedOptions.nativeModulesDir === 'string') {
+    outputOptions.nativeModulesDir = resolvePathMaybe(mergedOptions.nativeModulesDir, appRoot);
+  }
+  // exclude
+  if (Array.isArray(mergedOptions.exclude)) {
+    outputOptions.exclude = mergedOptions.exclude.filter((x) => typeof x === 'string');
+  }
+  // buildFromSource
+  if (Array.isArray(mergedOptions.buildFromSource)) {
+    outputOptions.buildFromSource = mergedOptions.buildFromSource.filter(
+      (x) => typeof x === 'string'
+    );
+  }
+  // flags
+  if (isJSONObject(mergedOptions.flags)) {
+    outputOptions.flags = { ...mergedOptions.flags };
+  }
+  return outputOptions;
+};
+
+/** Common commandline arguments for autolinking commands (Not to be confused with `AutolinkingOptions` */
+export interface AutolinkingCommonArguments {
+  projectRoot?: string | null;
+  // NOTE(@kitten): These are added to other `searchPaths` entries
+  searchPaths?: string[] | null;
+  // NOTE(@kitten): These are added to other `exclude` entries
+  exclude?: string[] | null;
+  platform?: SupportedPlatform | null;
+}
+
+export function registerAutolinkingArguments(command: commander.Command): commander.Command {
+  return command
+    .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(
+      // NOTE(@kitten): For backwards-compatibility, this is still called `project-root`, but it
+      // really is a replacement path for the current working directory. Henceforth called `commandRoot`
+      '--project-root <projectRoot>',
+      'The path to the root of the project. Defaults to current working directory',
+      process.cwd()
+    );
+}
+
+interface ArgumentsAutolinkingOptions {
+  /** The root directory that will be considered the base path for all other target paths */
+  commandRoot: string;
+  /** The platform to autolink against. If not passed or unknown, no specific autolinking search logic will be applied */
+  platform?: SupportedPlatform;
+  /** Added search paths to search for native modules (Usually passed as CLI rest argument. */
+  extraSearchPaths?: string[];
+  /** Added native module names to exclude from autolined native modules (Usually passed as CLI argument) */
+  extraExclude?: string[];
+}
+
+const parseExtraArgumentsOptions = (
+  args: AutolinkingCommonArguments
+): ArgumentsAutolinkingOptions => {
+  const cwd = process.cwd();
+  const platform = args.platform || undefined;
+  const commandRoot = resolvePathMaybe(args.projectRoot, cwd) || cwd;
+  const extraSearchPaths = filterMapSearchPaths(args.searchPaths, commandRoot);
+  const extraExclude = args.exclude?.filter((name) => typeof name === 'string');
+  return {
+    platform,
+    commandRoot,
+    extraSearchPaths,
+    extraExclude,
+  };
+};
+
+const findPackageJsonPathAsync = async (commandRoot: string | null): Promise<string> => {
+  const cwd = process.cwd();
+  const result = await findUp('package.json', { cwd: commandRoot || cwd });
+  if (!result) {
+    throw new Error(`Couldn't find "package.json" up from path "${commandRoot || cwd}"`);
+  }
+  return result;
+};
+
+const loadPackageJSONAsync = async (packageJsonPath: string): Promise<Record<string, unknown>> => {
+  const packageJsonText = await fs.promises.readFile(packageJsonPath, 'utf8');
+  return JSON.parse(packageJsonText);
+};
+
+export interface LinkingOptionsLoader {
+  getCommandRoot(): string;
+  getAppRoot(): Promise<string>;
+  getPlatformOptions<T extends SupportedPlatform | undefined>(
+    platform: T
+  ): Promise<AutolinkingOptions & { platform: T }>;
+  getPlatformOptions(): Promise<AutolinkingOptions>;
+}
+
+export function createAutolinkingOptionsLoader(
+  argumentsOptions?: AutolinkingCommonArguments
+): LinkingOptionsLoader {
+  const extraArgumentsOptions = parseExtraArgumentsOptions(argumentsOptions ?? {});
+  const { commandRoot } = extraArgumentsOptions;
+
+  let _packageJsonPath$: Promise<string> | undefined;
+  const getPackageJsonPath = () => {
+    return _packageJsonPath$ || (_packageJsonPath$ = findPackageJsonPathAsync(commandRoot));
+  };
+
+  let _packageJson$: Promise<Record<string, unknown>> | undefined;
+  const getPackageJson = async () =>
+    _packageJson$ || (_packageJson$ = loadPackageJSONAsync(await getPackageJsonPath()));
+
+  const getAppRoot = async () => path.dirname(await getPackageJsonPath());
+
+  return {
+    getCommandRoot: () => commandRoot,
+    getAppRoot,
+    async getPlatformOptions(platform = extraArgumentsOptions.platform) {
+      const packageJson = await getPackageJson();
+      const appRoot = await getAppRoot();
+      const options = parsePackageJsonOptions(packageJson, appRoot, platform);
+
+      if (extraArgumentsOptions.extraSearchPaths) {
+        options.searchPaths = [
+          ...extraArgumentsOptions.extraSearchPaths,
+          ...(options.searchPaths ?? []),
+        ];
+      }
+      if (extraArgumentsOptions.extraExclude) {
+        options.exclude = [...(options.exclude ?? []), ...extraArgumentsOptions.extraExclude];
+      }
+
+      return {
+        ...normalizeAutolinkingOptions(options, appRoot),
+        platform,
+      };
+    },
+  };
+}
+
+const normalizeAutolinkingOptions = (
+  options: Partial<AutolinkingOptions>,
+  appRoot: string
+): AutolinkingOptions => {
+  return {
+    legacy_shallowReactNativeLinking: options.legacy_shallowReactNativeLinking ?? false,
+    searchPaths: options.searchPaths ?? [],
+    nativeModulesDir: options.nativeModulesDir
+      ? (resolvePathMaybe(options.nativeModulesDir, appRoot) ?? null)
+      : (resolvePathMaybe('./modules', appRoot) ?? null),
+    exclude: options.exclude ?? [],
+    buildFromSource: options.buildFromSource,
+    flags: options.flags,
+  };
+};

package/src/commands/generateModulesProviderCommand.ts

@@ -0,0 +1,60 @@
+import commander from 'commander';
+
+import {
+  AutolinkingCommonArguments,
+  createAutolinkingOptionsLoader,
+  registerAutolinkingArguments,
+} from './autolinkingOptions';
+import { findModulesAsync } from '../autolinking/findModules';
+import { generateModulesProviderAsync } from '../autolinking/generatePackageList';
+import { resolveModulesAsync } from '../autolinking/resolveModules';
+
+interface GenerateModulesProviderArguments extends AutolinkingCommonArguments {
+  target: string;
+  entitlement?: string;
+  packages?: string[] | null;
+}
+
+/** Generates a source file listing all packages to link in the runtime */
+export function generateModulesProviderCommand(cli: commander.CommanderStatic) {
+  return registerAutolinkingArguments(cli.command('generate-modules-provider [searchPaths...]'))
+    .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.'
+    )
+    .action(
+      async (searchPaths: string[] | null, commandArguments: GenerateModulesProviderArguments) => {
+        const platform = commandArguments.platform ?? 'apple';
+        const autolinkingOptionsLoader = createAutolinkingOptionsLoader({
+          ...commandArguments,
+          searchPaths,
+        });
+        const autolinkingOptions = await autolinkingOptionsLoader.getPlatformOptions(platform);
+
+        const expoModulesSearchResults = await findModulesAsync({
+          autolinkingOptions: await autolinkingOptionsLoader.getPlatformOptions(platform),
+          appRoot: await autolinkingOptionsLoader.getAppRoot(),
+        });
+        const expoModulesResolveResults = await resolveModulesAsync(
+          expoModulesSearchResults,
+          autolinkingOptions
+        );
+
+        const includeModules = new Set(commandArguments.packages ?? []);
+        const filteredModules = expoModulesResolveResults.filter((module) =>
+          includeModules.has(module.packageName)
+        );
+
+        await generateModulesProviderAsync(filteredModules, {
+          platform,
+          targetPath: commandArguments.target,
+          entitlementPath: commandArguments.entitlement ?? null,
+        });
+      }
+    );
+}

package/src/commands/generatePackageListCommand.ts

@@ -0,0 +1,67 @@
+import commander from 'commander';
+
+import {
+  AutolinkingCommonArguments,
+  createAutolinkingOptionsLoader,
+  registerAutolinkingArguments,
+} from './autolinkingOptions';
+import { findModulesAsync } from '../autolinking/findModules';
+import { generatePackageListAsync } from '../autolinking/generatePackageList';
+import { resolveModulesAsync } from '../autolinking/resolveModules';
+import type { ModuleDescriptor } from '../types';
+
+interface GeneratePackageListArguments extends AutolinkingCommonArguments {
+  target: string;
+  namespace: string;
+  empty: boolean;
+}
+
+/** Generates a source file listing all packages to link.
+ * @privateRemarks
+ * This command is deprecated for apple platforms, use `generate-modules-provider` instead.
+ */
+export function generatePackageListCommand(cli: commander.CommanderStatic) {
+  return registerAutolinkingArguments(cli.command('generate-package-list [searchPaths...]'))
+    .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
+    )
+    .action(
+      async (searchPaths: string[] | null, commandArguments: GeneratePackageListArguments) => {
+        const platform = commandArguments.platform ?? 'android';
+        const autolinkingOptionsLoader = createAutolinkingOptionsLoader({
+          ...commandArguments,
+          searchPaths,
+        });
+
+        let expoModulesResolveResults: ModuleDescriptor[] = [];
+        if (!commandArguments.empty) {
+          const autolinkingOptions = await autolinkingOptionsLoader.getPlatformOptions(platform);
+
+          const expoModulesSearchResults = await findModulesAsync({
+            autolinkingOptions: await autolinkingOptionsLoader.getPlatformOptions(platform),
+            appRoot: await autolinkingOptionsLoader.getAppRoot(),
+          });
+          expoModulesResolveResults = await resolveModulesAsync(
+            expoModulesSearchResults,
+            autolinkingOptions
+          );
+        }
+
+        await generatePackageListAsync(expoModulesResolveResults, {
+          platform,
+          targetPath: commandArguments.target,
+          namespace: commandArguments.namespace,
+        });
+      }
+    );
+}

package/src/commands/reactNativeConfigCommand.ts

@@ -0,0 +1,50 @@
+import commander from 'commander';
+
+import {
+  AutolinkingCommonArguments,
+  createAutolinkingOptionsLoader,
+  registerAutolinkingArguments,
+} from './autolinkingOptions';
+import { createReactNativeConfigAsync } from '../reactNativeConfig';
+
+interface ReactNativeConfigArguments extends AutolinkingCommonArguments {
+  sourceDir?: string | null;
+  json?: boolean | null;
+}
+
+/** The react-native-config command (like RN CLI linking) */
+export function reactNativeConfigCommand(cli: commander.CommanderStatic) {
+  return registerAutolinkingArguments(cli.command('react-native-config [searchPaths...]'))
+    .option(
+      '-p, --platform [platform]',
+      'The platform that the resulting modules must support. Available options: "android", "ios"',
+      'ios'
+    )
+    .option('--source-dir <sourceDir>', 'The path to the native source directory')
+    .option('-j, --json', 'Output results in the plain JSON format.', () => true, false)
+    .action(async (searchPaths: string[] | null, commandArguments: ReactNativeConfigArguments) => {
+      // TODO(@kitten): Do we need to restrict this?
+      const platform = commandArguments.platform ?? 'ios';
+      if (platform !== 'android' && platform !== 'ios') {
+        throw new Error(`Unsupported platform: ${platform}`);
+      }
+
+      const autolinkingOptionsLoader = createAutolinkingOptionsLoader({
+        ...commandArguments,
+        searchPaths,
+      });
+
+      const reactNativeConfig = await createReactNativeConfigAsync({
+        autolinkingOptions: await autolinkingOptionsLoader.getPlatformOptions(platform),
+        appRoot: await autolinkingOptionsLoader.getAppRoot(),
+        // NOTE(@kitten): This is currently not validated, and assumed to be validated later
+        sourceDir: commandArguments.sourceDir ?? undefined,
+      });
+
+      if (commandArguments.json) {
+        console.log(JSON.stringify(reactNativeConfig));
+      } else {
+        console.log(require('util').inspect(reactNativeConfig, false, null, true));
+      }
+    });
+}