@builder/user-config

const { 
  applyCliOption, 
  applyUserConfig, 
  getEnhancedWebpackConfig, 
  defaultConfig 
} = require("@builder/user-config");

import { 
  applyCliOption, 
  applyUserConfig, 
  getEnhancedWebpackConfig, 
  defaultConfig 
} from "@builder/user-config";

const { applyUserConfig, applyCliOption, getEnhancedWebpackConfig } = require("@builder/user-config");

// Register user configuration options with a build plugin API
function buildPlugin(api, options) {
  // Apply user config options (alias, devServer, externals, etc.)
  applyUserConfig(api, { customConfigs: [] });
  
  // Apply CLI options (https, analyzer, disable-reload, etc.)
  applyCliOption(api, { customOptionConfig: {} });
}

// Get enhanced webpack configuration for a specific target
function enhanceWebpack(api, webpackConfig, babelConfig) {
  return getEnhancedWebpackConfig(api, {
    target: 'web',
    webpackConfig,
    babelConfig,
    libName: 'react'
  });
}

/**
 * Register CLI options with build system
 * @param api - Build API object with registerCliOption and log methods
 * @param options - Configuration options with optional customOptionConfig
 */
function applyCliOption(api: BuildAPI, options?: CliOptionConfig): void;

/**
 * Register user configuration options with build system
 * @param api - Build API object with registerUserConfig method
 * @param options - Configuration options with optional customConfigs array
 */
function applyUserConfig(api: BuildAPI, options?: UserConfigOptions): void;

/**
 * Create enhanced webpack configuration with build optimizations
 * @param api - Build API object with context
 * @param params - Configuration parameters for webpack enhancement
 */
function getEnhancedWebpackConfig(
  api: BuildAPI, 
  params: WebpackEnhancementParams
): WebpackConfig;

/**
 * Default configuration values for all user config options
 */
const defaultConfig: DefaultUserConfig;

interface UserConfigSchema {
  // Build Output
  outputDir?: string;           // Output directory (default: "build")
  publicPath?: string;          // Public path for assets (default: "/")
  filename?: string;            // Output filename pattern (default: "[name].js")
  hash?: string | boolean;      // Enable hash in filenames (default: false)
  
  // Module Resolution
  alias?: Record<string, string>;      // Path aliases (default: {})
  extensions?: string[];               // File extensions (default: ['.js', '.jsx', '.json', '.html', '.ts', '.tsx', '.rml'])
  modules?: string[];                  // Module directories (default: ['node_modules'])
  externals?: Record<string, any>;     // External dependencies (default: {})
  
  // Development
  devServer?: DevServerConfig;         // Development server settings
  mock?: boolean;                      // Enable mock server (default: true)
  proxy?: Record<string, any>;         // Proxy configuration (default: {})
  
  // Processing & Optimization
  minify?: boolean;                    // Enable minification
  sourceMap?: boolean;                 // Enable source maps
  browserslist?: string | object;      // Browser support targets
  
  // And 27 more options...
}

interface CliOptions {
  https?: boolean;              // Enable HTTPS in dev server
  analyzer?: boolean;           // Enable bundle analyzer
  'analyzer-port'?: number;     // Bundle analyzer port
  'disable-reload'?: boolean;   // Disable hot reload
  'disable-mock'?: boolean;     // Disable mock server
  'disable-open'?: boolean;     // Disable browser auto-open
  'disable-assets'?: boolean;   // Disable assets processing
  'debug-runtime'?: boolean;    // Enable debug runtime
  mode?: string;                // Set build mode
}

interface BuildAPI {
  registerCliOption(options: CliOptionDefinition[]): void;
  registerUserConfig(configs: UserConfigDefinition[]): void;
  modifyUserConfig(modifier: (config: any) => any): void;
  context: BuildContext;
  log: Logger;
}

interface BuildContext {
  command: string;              // Current command ('start' | 'build')
  commandArgs: Record<string, any>;  // Command line arguments
  userConfig: Record<string, any>;   // Current user configuration
  webpack: any;                      // Webpack instance
  rootDir: string;                   // Project root directory
}

interface WebpackEnhancementParams {
  target: string;               // Target platform ('web', 'weex', 'miniapp', etc.)
  webpackConfig: any;           // Webpack-chain configuration object
  babelConfig: any;             // Babel configuration object
  libName?: string;             // Library name (default: 'rax')
}

interface CliOptionConfig {
  customOptionConfig?: Record<string, CliOptionDefinition>;
}

interface UserConfigOptions {
  customConfigs?: UserConfigDefinition[];
}

interface CliOptionDefinition {
  name: string;
  commands: string[];           // Applicable commands (['start'], ['build'], ['start', 'build'])
  module?: string | false;      // Module name or false to disable
  configWebpack?: (config: any, value: any, context: BuildContext) => void;
}

interface UserConfigDefinition {
  name: string;
  validation: string | ((value: any) => boolean);
  defaultValue?: any;
  configWebpack?: (config: any, value: any, context: BuildContext, api: BuildAPI) => void;
}