@rspack/cli 2.0.0 → 2.0.2

package/dist/exit-hook.js

@@ -3,11 +3,42 @@ const asyncCallbacks = new Set();
 const callbacks = new Set();
 let isCalled = false;
 let isRegistered = false;
+async function flushStdio() {
+    const flush = (stream)=>new Promise((resolve)=>{
+            if (!stream || !stream.writable || stream.writableEnded || stream.destroyed) return void resolve();
+            const onError = ()=>{
+                stream.off('error', onError);
+                resolve();
+            };
+            stream.once('error', onError);
+            try {
+                stream.write('', ()=>{
+                    stream.off('error', onError);
+                    resolve();
+                });
+            } catch  {
+                stream.off('error', onError);
+                resolve();
+            }
+        });
+    const timeout = new Promise((resolve)=>{
+        setTimeout(resolve, 1000);
+    });
+    await Promise.race([
+        Promise.all([
+            flush(node_process.stdout),
+            flush(node_process.stderr)
+        ]),
+        timeout
+    ]);
+}
 async function exit(shouldManuallyExit, isSynchronous, signal) {
     if (isCalled) return;
     isCalled = true;
     if (asyncCallbacks.size > 0 && isSynchronous) console.error("SYNCHRONOUS TERMINATION NOTICE: When explicitly exiting the process via process.exit or via a parent process, asynchronous tasks in your exitHooks will not run. Either remove these tasks, use gracefulExit() instead of process.exit(), or ensure your parent process sends a SIGINT to the process running this code.");
-    const exitCode = 128 + signal;
+    let exitCode = 0;
+    if (signal > 0) exitCode = 128 + signal;
+    else if ('number' == typeof node_process.exitCode || 'string' == typeof node_process.exitCode) exitCode = node_process.exitCode;
     const done = (force = false)=>{
         if (true === force || true === shouldManuallyExit) node_process.exit(exitCode);
     };
@@ -19,11 +50,12 @@ async function exit(shouldManuallyExit, isSynchronous, signal) {
         forceAfter = Math.max(forceAfter, wait);
         promises.push(Promise.resolve(callback(exitCode)));
     }
-    const asyncTimer = setTimeout(()=>{
+    const asyncTimer = forceAfter > 0 ? setTimeout(()=>{
         done(true);
-    }, forceAfter);
+    }, forceAfter) : void 0;
     await Promise.all(promises);
     clearTimeout(asyncTimer);
+    await flushStdio();
     done();
 }
 function addHook(options) {

package/dist/index.d.ts

@@ -1,2 +1,301 @@
-export { defineConfig, definePlugin, RspackCLI } from './cli';
-export * from './types';
+import type { Compiler } from '@rspack/core';
+import { Configuration } from '@rspack/core';
+import type { MultiCompiler } from '@rspack/core';
+import type { MultiRspackOptions } from '@rspack/core';
+import type { MultiStats } from '@rspack/core';
+import type { RspackOptions } from '@rspack/core';
+import type { RspackPluginFunction } from '@rspack/core';
+import type { RspackPluginInstance } from '@rspack/core';
+import type { Stats } from '@rspack/core';
+
+declare class CAC extends EventTarget {
+    /** The program name to display in help and version message */
+    name: string;
+    commands: Command[];
+    globalCommand: GlobalCommand;
+    matchedCommand?: Command;
+    matchedCommandName?: string;
+    /**
+     * Raw CLI arguments
+     */
+    rawArgs: string[];
+    /**
+     * Parsed CLI arguments
+     */
+    args: ParsedArgv["args"];
+    /**
+     * Parsed CLI options, camelCased
+     */
+    options: ParsedArgv["options"];
+    showHelpOnExit?: boolean;
+    showVersionOnExit?: boolean;
+    /**
+     * @param name The program name to display in help and version message
+     */
+    constructor(name?: string);
+    /**
+     * Add a global usage text.
+     *
+     * This is not used by sub-commands.
+     */
+    usage(text: string): this;
+    /**
+     * Add a sub-command
+     */
+    command(rawName: string, description?: string, config?: CommandConfig): Command;
+    /**
+     * Add a global CLI option.
+     *
+     * Which is also applied to sub-commands.
+     */
+    option(rawName: string, description: string, config?: OptionConfig): this;
+    /**
+     * Show help message when `-h, --help` flags appear.
+     *
+     */
+    help(callback?: HelpCallback): this;
+    /**
+     * Show version number when `-v, --version` flags appear.
+     *
+     */
+    version(version: string, customFlags?: string): this;
+    /**
+     * Add a global example.
+     *
+     * This example added here will not be used by sub-commands.
+     */
+    example(example: CommandExample): this;
+    /**
+     * Output the corresponding help message
+     * When a sub-command is matched, output the help message for the command
+     * Otherwise output the global one.
+     *
+     */
+    outputHelp(): void;
+    /**
+     * Output the version number.
+     *
+     */
+    outputVersion(): void;
+    private setParsedInfo;
+    unsetMatchedCommand(): void;
+    /**
+     * Parse argv
+     */
+    parse(argv?: string[], {
+        run
+    }?: {
+        /** Whether to run the action for matched command */run?: boolean | undefined;
+    }): ParsedArgv;
+    private mri;
+    runMatchedCommand(): any;
+}
+
+declare class Command {
+    rawName: string;
+    description: string;
+    config: CommandConfig;
+    cli: CAC;
+    options: Option_2[];
+    aliasNames: string[];
+    name: string;
+    args: CommandArg[];
+    commandAction?: (...args: any[]) => any;
+    usageText?: string;
+    versionNumber?: string;
+    examples: CommandExample[];
+    helpCallback?: HelpCallback;
+    globalCommand?: GlobalCommand;
+    constructor(rawName: string, description: string, config: CommandConfig | undefined, cli: CAC);
+    usage(text: string): this;
+    allowUnknownOptions(): this;
+    ignoreOptionDefaultValue(): this;
+    version(version: string, customFlags?: string): this;
+    example(example: CommandExample): this;
+    /**
+     * Add a option for this command
+     * @param rawName Raw option name(s)
+     * @param description Option description
+     * @param config Option config
+     */
+    option(rawName: string, description: string, config?: OptionConfig): this;
+    alias(name: string): this;
+    action(callback: (...args: any[]) => any): this;
+    /**
+     * Check if a command name is matched by this command
+     * @param name Command name
+     */
+    isMatched(name: string): boolean;
+    get isDefaultCommand(): boolean;
+    get isGlobalCommand(): boolean;
+    /**
+     * Check if an option is registered in this command
+     * @param name Option name
+     */
+    hasOption(name: string): Option_2 | undefined;
+    outputHelp(): void;
+    outputVersion(): void;
+    checkRequiredArgs(): void;
+    /**
+     * Check if the parsed options contain any unknown options
+     *
+     * Exit and output error when true
+     */
+    checkUnknownOptions(): void;
+    /**
+     * Check if the required string-type options exist
+     */
+    checkOptionValue(): void;
+    /**
+     * Check if the number of args is more than expected
+     */
+    checkUnusedArgs(): void;
+}
+
+declare type Command_2 = 'serve' | 'build';
+
+declare interface CommandArg {
+    required: boolean;
+    value: string;
+    variadic: boolean;
+}
+
+declare interface CommandConfig {
+    allowUnknownOptions?: boolean;
+    ignoreOptionDefaultValue?: boolean;
+}
+
+declare type CommandExample = ((bin: string) => string) | string;
+
+declare type CommonOptions = {
+    config?: string;
+    configName?: string[];
+    configLoader?: ConfigLoader;
+    env?: Record<string, unknown> | string[];
+    nodeEnv?: string;
+};
+
+declare type CommonOptionsForBuildAndServe = CommonOptions & {
+    devtool?: string | boolean;
+    entry?: string[];
+    mode?: string;
+    outputPath?: string;
+    watch?: boolean;
+};
+
+declare type ConfigLoader = 'auto' | 'jiti' | 'native';
+
+export { Configuration }
+
+/**
+ * This function helps you to autocomplete configuration types.
+ * It accepts a Rspack config object, or a function that returns a config.
+ */
+export declare function defineConfig(config: RspackOptions): RspackOptions;
+
+export declare function defineConfig(config: MultiRspackOptions): MultiRspackOptions;
+
+export declare function defineConfig(config: RspackConfigFn): RspackConfigFn;
+
+export declare function defineConfig(config: RspackConfigAsyncFn): RspackConfigAsyncFn;
+
+export declare function defineConfig(config: RspackConfigExport): RspackConfigExport;
+
+export declare function definePlugin(plugin: RspackPluginFunction): RspackPluginFunction;
+
+export declare function definePlugin(plugin: RspackPluginInstance): RspackPluginInstance;
+
+declare class GlobalCommand extends Command {
+    constructor(cli: CAC);
+}
+
+declare type HelpCallback = (sections: HelpSection[]) => void | HelpSection[];
+
+declare interface HelpSection {
+    title?: string;
+    body: string;
+}
+
+export declare type LogHandler = (value: any) => void;
+
+declare class Option_2 {
+    rawName: string;
+    description: string;
+    /** Option name */
+    name: string;
+    /** Option name and aliases */
+    names: string[];
+    isBoolean?: boolean;
+    required?: boolean;
+    config: OptionConfig;
+    negated: boolean;
+    constructor(rawName: string, description: string, config?: OptionConfig);
+}
+
+declare interface OptionConfig {
+    default?: any;
+    type?: any[];
+}
+
+declare interface ParsedArgv {
+    args: ReadonlyArray<string>;
+    options: {
+        [k: string]: any;
+    };
+}
+
+export declare class RspackCLI {
+    colors: RspackCLIColors;
+    program: CAC;
+    _actionPromise: Promise<void> | undefined;
+    constructor();
+    /**
+     * Wraps an async action handler so its promise is captured and can be
+     * awaited in `run()`. CAC's `parse()` does not await async actions,
+     * so without this wrapper, rejections become unhandled.
+     */
+    wrapAction<T extends (...args: any[]) => Promise<void>>(fn: T): T;
+    buildCompilerConfig(options: CommonOptionsForBuildAndServe, rspackCommand: Command_2): Promise<RspackOptions | MultiRspackOptions>;
+    createCompiler(config: RspackOptions | MultiRspackOptions, callback?: (e: Error | null, res?: Stats | MultiStats) => void): Promise<MultiCompiler | Compiler | null>;
+    private createColors;
+    getLogger(): RspackCLILogger;
+    run(argv: string[]): Promise<void>;
+    private registerCommands;
+    private buildConfig;
+    loadConfig(options: CommonOptions): Promise<{
+        config: RspackOptions | MultiRspackOptions;
+        pathMap: WeakMap<RspackOptions, string[]>;
+    }>;
+    private filterConfig;
+    isMultipleCompiler(compiler: Compiler | MultiCompiler): compiler is MultiCompiler;
+    isWatch(compiler: Compiler | MultiCompiler): boolean;
+}
+
+export declare interface RspackCLIColors {
+    isColorSupported: boolean;
+    red(text: string): string;
+    yellow(text: string): string;
+    cyan(text: string): string;
+    green(text: string): string;
+}
+
+export declare interface RspackCLILogger {
+    error: LogHandler;
+    warn: LogHandler;
+    info: LogHandler;
+    success: LogHandler;
+    log: LogHandler;
+    raw: LogHandler;
+}
+
+export declare interface RspackCommand {
+    apply(cli: RspackCLI): Promise<void>;
+}
+
+declare type RspackConfigAsyncFn = (env: Record<string, any>, argv: Record<string, any>) => Promise<RspackOptions | MultiRspackOptions>;
+
+declare type RspackConfigExport = RspackOptions | MultiRspackOptions | RspackConfigFn | RspackConfigAsyncFn;
+
+declare type RspackConfigFn = (env: Record<string, any>, argv: Record<string, any>) => RspackOptions | MultiRspackOptions;
+
+export { }