@rspack/cli 2.0.0-rc.3 → 2.0.1

package/dist/162.js

@@ -824,7 +824,7 @@ async function getPreviewConfig(item, options, dir) {
                 publicPath: options.publicPath ?? '/'
             },
             hot: false,
-            port: options.port ?? 8080,
+            port: options.port ?? devServer?.port ?? 8080,
             proxy: devServer?.proxy,
             host: options.host ?? devServer?.host,
             open: options.open ?? devServer?.open,
@@ -844,7 +844,7 @@ function normalizeHotOption(value) {
 class ServeCommand {
     async apply(cli) {
         const command = cli.program.command('serve', 'run the rspack dev server.').alias('server').alias('s').alias('dev');
-        commonOptionsForBuildAndServe(commonOptions(command)).option('--hot [mode]', 'enables hot module replacement').option('--port <port>', 'allows to specify a port to use').option('--host <host>', 'allows to specify a hostname to use');
+        commonOptionsForBuildAndServe(commonOptions(command)).option('--hot [mode]', 'enables hot module replacement').option('--port <port>', 'allows to specify a port to use').option('--host <host>', 'allows to specify a hostname to use').option('--open [value]', 'open browser on server start; pass --no-open to disable, or --open <url> to open a specific URL');
         command.action(cli.wrapAction(async (cliOptions)=>{
             setDefaultNodeEnv(cliOptions, 'development');
             normalizeCommonOptions(cliOptions, 'serve');
@@ -910,6 +910,7 @@ class ServeCommand {
             devServerOptions.hot = cliOptions.hot ?? devServerOptions.hot ?? true;
             devServerOptions.host = cliOptions.host || devServerOptions.host;
             devServerOptions.port = cliOptions.port ?? devServerOptions.port;
+            if (void 0 !== cliOptions.open) devServerOptions.open = cliOptions.open;
             if (false !== devServerOptions.client) {
                 if (true === devServerOptions.client || null == devServerOptions.client) devServerOptions.client = {};
                 devServerOptions.client = {
@@ -1131,7 +1132,7 @@ class RspackCLI {
         this.colors = this.createColors();
         this.program = program;
         program.help();
-        program.version("2.0.0-rc.3");
+        program.version("2.0.1");
     }
     wrapAction(fn) {
         return (...args)=>{

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 { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/cli",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.1",
   "description": "CLI for rspack",
   "homepage": "https://rspack.rs",
   "bugs": "https://github.com/web-infra-dev/rspack/issues",
@@ -29,8 +29,9 @@
   ],
   "devDependencies": {
     "@discoveryjs/json-ext": "^0.5.7",
-    "@rslib/core": "0.21.0",
-    "@rspack/dev-server": "2.0.0-rc.2",
+    "@microsoft/api-extractor": "^7.58.7",
+    "@rslib/core": "0.21.3",
+    "@rspack/dev-server": "^2.0.1",
     "cac": "^7.0.0",
     "concat-stream": "^2.0.0",
     "cross-env": "^10.1.0",
@@ -38,9 +39,9 @@
     "exit-hook": "^4.0.0",
     "jiti": "^2.6.1",
     "prebundle": "^1.6.4",
-    "typescript": "^6.0.2",
-    "@rspack/test-tools": "2.0.0-rc.3",
-    "@rspack/core": "2.0.0-rc.3"
+    "typescript": "^6.0.3",
+    "@rspack/core": "2.0.1",
+    "@rspack/test-tools": "2.0.1"
   },
   "peerDependencies": {
     "@rspack/core": "^2.0.0-0",

package/dist/cli.d.ts

@@ -1,49 +0,0 @@
-import type { Compiler, MultiCompiler, MultiRspackOptions, MultiStats, RspackOptions, RspackPluginFunction, RspackPluginInstance, Stats } from '@rspack/core';
-import { type CAC } from 'cac';
-import type { RspackCLIColors, RspackCLILogger } from './types';
-import type { CommonOptions, CommonOptionsForBuildAndServe } from './utils/options';
-type Command = 'serve' | 'build';
-declare global {
-    const RSPACK_CLI_VERSION: string;
-}
-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): 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 type RspackConfigFn = (env: Record<string, any>, argv: Record<string, any>) => RspackOptions | MultiRspackOptions;
-export type RspackConfigAsyncFn = (env: Record<string, any>, argv: Record<string, any>) => Promise<RspackOptions | MultiRspackOptions>;
-export type RspackConfigExport = RspackOptions | MultiRspackOptions | RspackConfigFn | RspackConfigAsyncFn;
-/**
- * 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;
-export {};

package/dist/commands/build.d.ts

@@ -1,5 +0,0 @@
-import type { RspackCLI } from '../cli';
-import type { RspackCommand } from '../types';
-export declare class BuildCommand implements RspackCommand {
-    apply(cli: RspackCLI): Promise<void>;
-}

package/dist/commands/preview.d.ts

@@ -1,5 +0,0 @@
-import type { RspackCLI } from '../cli';
-import type { RspackCommand } from '../types';
-export declare class PreviewCommand implements RspackCommand {
-    apply(cli: RspackCLI): Promise<void>;
-}

package/dist/commands/serve.d.ts

@@ -1,5 +0,0 @@
-import type { RspackCLI } from '../cli';
-import type { RspackCommand } from '../types';
-export declare class ServeCommand implements RspackCommand {
-    apply(cli: RspackCLI): Promise<void>;
-}

package/dist/constants.d.ts

@@ -1,3 +0,0 @@
-export declare const DEFAULT_CONFIG_NAME: "rspack.config";
-export declare const DEFAULT_EXTENSIONS: readonly [".ts", ".js", ".mts", ".mjs", ".cts", ".cjs"];
-export declare const DEFAULT_SERVER_HOT = true;

package/dist/types.d.ts

@@ -1,21 +0,0 @@
-import type { RspackCLI } from './cli';
-export type { Configuration } from '@rspack/core';
-export type LogHandler = (value: any) => void;
-export interface RspackCLIColors {
-    isColorSupported: boolean;
-    red(text: string): string;
-    yellow(text: string): string;
-    cyan(text: string): string;
-    green(text: string): string;
-}
-export interface RspackCLILogger {
-    error: LogHandler;
-    warn: LogHandler;
-    info: LogHandler;
-    success: LogHandler;
-    log: LogHandler;
-    raw: LogHandler;
-}
-export interface RspackCommand {
-    apply(cli: RspackCLI): Promise<void>;
-}

package/dist/utils/findConfig.d.ts

@@ -1,6 +0,0 @@
-/**
- * Takes a basePath like `webpack.config`, return `webpack.config.{ext}` if
- * exists. returns undefined if none of them exists
- */
-declare const findConfig: (basePath: string) => string | undefined;
-export default findConfig;

package/dist/utils/isTsFile.d.ts

@@ -1,3 +0,0 @@
-export declare const TS_EXTENSION: string[];
-declare const isTsFile: (configPath: string) => boolean;
-export default isTsFile;

package/dist/utils/loadConfig.d.ts

@@ -1,28 +0,0 @@
-import type { MultiRspackOptions, RspackOptions } from '@rspack/core';
-import type { CommonOptions } from './options';
-export type LoadedRspackConfig = undefined | RspackOptions | MultiRspackOptions | ((env: Record<string, any>, argv?: Record<string, any>) => RspackOptions | MultiRspackOptions | Promise<RspackOptions | MultiRspackOptions>);
-export declare const resolveRspackConfigExport: (configExport: LoadedRspackConfig, options: CommonOptions) => Promise<RspackOptions | MultiRspackOptions>;
-/**
- * Loads and merges configurations from the 'extends' property
- * @param config The configuration object that may contain an 'extends' property
- * @param configPath The path to the configuration file
- * @param cwd The current working directory
- * @param options CLI options
- * @returns The merged configuration
- */
-export declare function loadExtendedConfig(config: RspackOptions, configPath: string, cwd: string, options: CommonOptions): Promise<{
-    config: RspackOptions;
-    pathMap: WeakMap<RspackOptions, string[]>;
-}>;
-export declare function loadExtendedConfig(config: MultiRspackOptions, configPath: string, cwd: string, options: CommonOptions): Promise<{
-    config: MultiRspackOptions;
-    pathMap: WeakMap<RspackOptions, string[]>;
-}>;
-export declare function loadExtendedConfig(config: RspackOptions | MultiRspackOptions, configPath: string, cwd: string, options: CommonOptions): Promise<{
-    config: RspackOptions | MultiRspackOptions;
-    pathMap: WeakMap<RspackOptions, string[]>;
-}>;
-export declare function loadRspackConfig(options: CommonOptions, cwd?: string): Promise<{
-    loadedConfig: LoadedRspackConfig;
-    configPath: string;
-} | null>;

package/dist/utils/options.d.ts

@@ -1,28 +0,0 @@
-import type { Command } from 'cac';
-export type ConfigLoader = 'auto' | 'jiti' | 'native';
-/**
- * Apply common options for all commands
- */
-export declare const commonOptions: (command: Command) => Command;
-export type CommonOptions = {
-    config?: string;
-    configName?: string[];
-    configLoader?: ConfigLoader;
-    env?: Record<string, unknown> | string[];
-    nodeEnv?: string;
-};
-export declare const normalizeCommonOptions: (options: CommonOptions | CommonOptionsForBuildAndServe, action: "serve" | "build" | "preview") => void;
-/**
- * Apply common options for `build` and `serve` commands
- */
-export declare const commonOptionsForBuildAndServe: (command: Command) => Command;
-export type CommonOptionsForBuildAndServe = CommonOptions & {
-    devtool?: string | boolean;
-    entry?: string[];
-    mode?: string;
-    outputPath?: string;
-    watch?: boolean;
-};
-export declare function setDefaultNodeEnv(options: {
-    nodeEnv?: unknown;
-}, defaultEnv: string): void;

package/dist/utils/profile.d.ts

@@ -1 +0,0 @@
-export declare function applyProfile(filterValue: string, traceLayer?: string, traceOutput?: string): Promise<void>;