Configuration Loading

/**
 * Loads Metro configuration from various sources with automatic discovery
 * @param argvInput - CLI arguments and configuration options (optional)
 * @param defaultConfigOverrides - Base config overrides (optional)
 * @returns Promise resolving to complete Metro configuration
 */
function loadConfig(
  argvInput?: YargArguments,
  defaultConfigOverrides?: InputConfigT
): Promise<ConfigT>;

import { loadConfig } from "metro-config";

// Auto-discover config file in current directory
const config = await loadConfig();

// Load from specific config file
const config = await loadConfig({
  config: './metro.config.js'
});

// Override with CLI arguments
const config = await loadConfig({
  config: './metro.config.js',
  port: 3000,
  projectRoot: './src',
  resetCache: true
});

// With workspace configuration
const config = await loadConfig({
  cwd: './packages/mobile',
  watchFolders: ['./packages/shared']
});

// With default config overrides
const config = await loadConfig(
  { config: './metro.config.js' },
  { 
    resolver: { sourceExts: ['js', 'jsx', 'ts', 'tsx'] },
    server: { port: 3000 }
  }
);

/**
 * Resolves configuration file path and loads the config
 * @param filePath - Explicit path to config file (optional)
 * @param cwd - Current working directory for search (optional)
 * @returns Promise resolving to config resolution result
 */
function resolveConfig(filePath?: string, cwd?: string): Promise<ResolveConfigResult>;

interface ResolveConfigResult {
  /** Absolute path to the resolved config file */
  filepath: string;
  /** Whether the config is empty (no file found) */
  isEmpty: boolean;
  /** The loaded configuration object or function */
  config: (ConfigT => Promise<ConfigT>) | (ConfigT => ConfigT) | InputConfigT;
}

type ResolveConfigResult = $ReadOnly<{
  filepath: string,
  isEmpty: boolean,
  config: (ConfigT => Promise<ConfigT>) | (ConfigT => ConfigT) | InputConfigT,
}>;

import { resolveConfig } from "metro-config";

// Auto-discover config file
const result = await resolveConfig();
if (!result.isEmpty) {
  console.log(`Found config at: ${result.filepath}`);
}

// Search from specific directory
const result = await resolveConfig(undefined, './packages/mobile');

// Load specific file
const result = await resolveConfig('./custom-metro.config.js');

/**
 * Loads a configuration file from an absolute path
 * @param absolutePath - Absolute path to the config file
 * @returns Promise resolving to config resolution result
 */
function loadConfigFile(absolutePath: string): Promise<ResolveConfigResult>;

import { loadConfigFile } from "metro-config";

// Load specific config file
const result = await loadConfigFile('/absolute/path/to/metro.config.js');

// Check if config was loaded successfully
if (!result.isEmpty) {
  console.log(`Loaded config from: ${result.filepath}`);
  
  // Handle function vs object config
  if (typeof result.config === 'function') {
    console.log('Config is a function that will receive default config');
  } else {
    console.log('Config is a static object');
  }
}

// metro.config.js
module.exports = {
  resolver: {
    sourceExts: ['js', 'jsx', 'ts', 'tsx']
  },
  server: {
    port: 8081
  }
};

// metro.config.js
module.exports = async (defaultConfig) => {
  return {
    ...defaultConfig,
    resolver: {
      ...defaultConfig.resolver,
      sourceExts: [...defaultConfig.resolver.sourceExts, 'svg']
    }
  };
};

// metro.config.ts
import type { ConfigT } from 'metro-config';

const config: ConfigT = {
  resolver: {
    sourceExts: ['js', 'jsx', 'ts', 'tsx']
  }
};

export default config;

{
  "metro": {
    "resolver": {
      "sourceExts": ["js", "jsx", "ts", "tsx"]
    }
  }
}

type YargArguments = $ReadOnly<{
  /** Path to configuration file */
  config?: string,
  /** Current working directory */
  cwd?: string,
  /** Development server port */
  port?: string | number,
  /** Development server host */
  host?: string,
  /** Project root directory */
  projectRoot?: string,
  /** Additional watch folders */
  watchFolders?: Array<string>,
  /** Asset file extensions */
  assetExts?: Array<string>,
  /** Source file extensions */
  sourceExts?: Array<string>,
  /** Supported platforms */
  platforms?: Array<string>,
  /** Maximum worker processes */
  'max-workers'?: string | number,
  maxWorkers?: string | number,
  /** Transformer module path */
  transformer?: string,
  /** Reset Metro cache */
  'reset-cache'?: boolean,
  resetCache?: boolean,
  /** Verbose logging */
  verbose?: boolean,
}>;

// Override configuration with CLI arguments
const config = await loadConfig({
  config: './metro.config.js',
  port: 3000,
  resetCache: true,
  maxWorkers: 4,
  watchFolders: ['./packages/shared', './packages/common'],
  sourceExts: ['js', 'jsx', 'ts', 'tsx', 'json']
});

import { loadConfig } from "metro-config";

try {
  const config = await loadConfig({
    config: './invalid-config.js'
  });
} catch (error) {
  if (error.code === 'MODULE_NOT_FOUND') {
    console.error('Configuration file not found');
  } else if (error.name === 'ValidationError') {
    console.error('Invalid configuration:', error.message);
  } else {
    console.error('Configuration loading failed:', error);
  }
}