HappyPack

const HappyPack = require('happypack');

const HappyPack = require('happypack');
const HappyThreadPool = HappyPack.ThreadPool;

// The loader is accessed via the package path
require('happypack/loader')

// In webpack configuration
use: 'happypack/loader'

// webpack.config.js
const HappyPack = require('happypack');

module.exports = {
  module: {
    rules: [
      {
        test: /\.js$/,
        use: 'happypack/loader',
        include: [/* ... */],
        exclude: [/* ... */]
      }
    ]
  },
  plugins: [
    new HappyPack({
      loaders: ['babel-loader?presets[]=es2015']
    })
  ]
};

/**
 * Creates a new HappyPack plugin instance
 * @param userConfig - Configuration object
 * @returns HappyPlugin instance
 */
function HappyPlugin(userConfig);

interface HappyPluginConfig {
  /** Unique identifier for this plugin instance */
  id?: string;
  /** Number of background threads to spawn */
  threads?: number;
  /** Pre-defined thread pool to use */
  threadPool?: HappyThreadPool;
  /** Array of loader configurations */
  loaders: LoaderConfig[];
  /** Alias for loaders property */
  use?: LoaderConfig[];
  /** Enable status logging */
  verbose?: boolean;
  /** Enable logging during webpack profiling */
  verboseWhenProfiling?: boolean;
  /** Enable debug logging */
  debug?: boolean;
  /** Compiler identifier for multi-compiler setups */
  compilerId?: string;
  /** Windows compatibility messaging mode */
  bufferedMessaging?: boolean;
}

type LoaderConfig = string | {
  loader?: string;
  path?: string;
  query?: string | object;
  options?: object;
};

/**
 * Creates a shared thread pool for multiple HappyPack instances
 * @param config - Thread pool configuration
 * @returns Thread pool instance
 */
HappyPack.ThreadPool(config);

interface ThreadPoolConfig {
  /** Number of worker threads to create */
  size: number;
  /** Optional identifier for logging */
  id?: string;
  /** Enable verbose logging */
  verbose?: boolean;
  /** Enable debug logging */
  debug?: boolean;
  /** Enable Windows compatibility mode */
  bufferedMessaging?: boolean;
}

interface ThreadPool {
  /** Number of threads in the pool */
  size: number;
  /** Initialize the thread pool */
  start(compilerId: string, compiler: object, compilerOptions: string, done: function): void;
  /** Check if thread pool is running */
  isRunning(): boolean;
  /** Compile files using the thread pool */
  compile(loaderId: string, loader: object, params: object, done: function): void;
  /** Shutdown the thread pool */
  stop(compilerId: string): void;
}

/**
 * HappyPack webpack loader function
 * @param sourceCode - Source file content
 * @param sourceMap - Source map data
 * @returns Processed source code and source map via callback
 */
function HappyLoader(sourceCode, sourceMap);

// Basic usage
use: 'happypack/loader'

// With specific plugin ID
use: 'happypack/loader?id=babel'

// With compiler ID for multi-compiler setups
use: 'happypack/loader?id=babel&compilerId=main'

class HappyPlugin {
  constructor(userConfig: HappyPluginConfig);
  
  /** Plugin name identifier */
  name: string;
  /** Plugin configuration */
  config: HappyPluginConfig;
  /** Plugin ID */
  id: string;
  /** Thread pool instance */
  threadPool: ThreadPool;
  
  /**
   * Webpack plugin interface method - registers plugin hooks
   * @param compiler - Webpack compiler instance
   */
  apply(compiler: object): void;
  
  /**
   * Initialize plugin and start thread pool
   * @param compiler - Webpack compiler instance
   * @param done - Completion callback function
   */
  start(compiler: object, done: function): void;
  
  /** Shutdown thread pool and cleanup resources */
  stop(): void;
  
  /**
   * Compile files using the thread pool
   * @param loaderContext - Webpack loader context
   * @param params - Compilation parameters including sourceCode, sourceMap, resource
   * @param done - Completion callback with (error, result)
   */
  compile(loaderContext: object, params: object, done: function): void;
  
  /**
   * Generate webpack loader request string for a resource
   * @param resource - File resource path
   * @returns Formatted loader request string
   */
  generateRequest(resource: string): string;
}

/** List of webpack options that can be serialized to workers */
HappyPlugin.SERIALIZABLE_OPTIONS: string[];

/** Reference to HappyThreadPool constructor for convenience */
HappyPlugin.ThreadPool: function;