/// <reference types="node" />
import webpack, { EntryOptions, Stats, Configuration, WebpackError, StatsOptions, WebpackOptionsNormalized, Compiler, MultiCompiler, Problem, Argument, AssetEmittedInfo, FileCacheOptions } from "webpack";
import { ClientConfiguration, Configuration as DevServerConfig } from "webpack-dev-server";
import { Colorette } from "colorette";
import { Command, CommandOptions, Option, ParseOptions } from "commander";
import { prepare } from "rechoir";
import { stringifyStream } from "@discoveryjs/json-ext";
/**
* Webpack CLI
*/
interface IWebpackCLI {
colors: WebpackCLIColors;
logger: WebpackCLILogger;
isColorSupportChanged: boolean | undefined;
webpack: typeof webpack;
builtInOptionsCache: WebpackCLIBuiltInOption[] | undefined;
program: WebpackCLICommand;
isMultipleCompiler(compiler: WebpackCompiler): compiler is MultiCompiler;
isPromise<T>(value: Promise<T>): value is Promise<T>;
isFunction(value: unknown): value is CallableFunction;
getLogger(): WebpackCLILogger;
createColors(useColors?: boolean): WebpackCLIColors;
toKebabCase: StringFormatter;
capitalizeFirstLetter: StringFormatter;
checkPackageExists(packageName: string): boolean;
getAvailablePackageManagers(): PackageManager[];
getDefaultPackageManager(): PackageManager | undefined;
doInstall(packageName: string, options?: PackageInstallOptions): Promise<string>;
loadJSONFile<T = unknown>(path: Path, handleError: boolean): Promise<T>;
tryRequireThenImport<T = unknown>(module: ModuleName, handleError: boolean): Promise<T>;
getInfoOptions(): WebpackCLIBuiltInOption[];
getInfoOutput(options: {
output: string;
additionalPackage: string[];
}): Promise<string>;
makeCommand(commandOptions: WebpackCLIOptions, options: WebpackCLICommandOptions, action: CommandAction): Promise<WebpackCLICommand | undefined>;
makeOption(command: WebpackCLICommand, option: WebpackCLIBuiltInOption): void;
run(args: Parameters<WebpackCLICommand["parseOptions"]>[0], parseOptions?: ParseOptions): Promise<void>;
getBuiltInOptions(): WebpackCLIBuiltInOption[];
loadWebpack(handleError?: boolean): Promise<typeof webpack>;
loadConfig(options: Partial<WebpackDevServerOptions>): Promise<WebpackCLIConfig>;
buildConfig(config: WebpackCLIConfig, options: WebpackDevServerOptions): Promise<WebpackCLIConfig>;
isValidationError(error: Error): error is WebpackError;
createCompiler(options: Partial<WebpackDevServerOptions>, callback?: Callback<[Error | undefined, WebpackCLIStats | undefined]>): Promise<WebpackCompiler>;
needWatchStdin(compiler: Compiler | MultiCompiler): boolean;
runWebpack(options: WebpackRunOptions, isWatchCommand: boolean): Promise<void>;
}
interface WebpackCLIColors extends Colorette {
isColorSupported: boolean;
}
interface WebpackCLILogger {
error: LogHandler;
warn: LogHandler;
info: LogHandler;
success: LogHandler;
log: LogHandler;
raw: LogHandler;
}
interface WebpackCLICommandOption extends CommanderOption {
helpLevel?: "minimum" | "verbose";
}
interface WebpackCLIConfig {
options: WebpackConfiguration | WebpackConfiguration[];
path: WeakMap<object, string>;
}
interface WebpackCLICommand extends Command {
pkg: string | undefined;
forHelp: boolean | undefined;
options: WebpackCLICommandOption[];
_args: WebpackCLICommandOption[];
}
interface WebpackCLIStats extends Stats {
presetToOptions?: (item: string | boolean) => StatsOptions;
}
declare type WebpackCLIMainOption = Pick<WebpackCLIBuiltInOption, "description" | "defaultValue" | "multiple"> & {
flags: string;
type: Set<BooleanConstructor | StringConstructor | NumberConstructor>;
};
interface WebpackCLIOptions extends CommandOptions {
name: string;
alias: string | string[];
description?: string;
usage?: string;
dependencies?: string[];
pkg?: string;
argsDescription?: {
[argName: string]: string;
};
}
declare type WebpackCLICommandOptions = WebpackCLIBuiltInOption[] | (() => Promise<WebpackCLIBuiltInOption[]>);
interface WebpackCLIBuiltInFlag {
name: string;
alias?: string;
type?: (value: string, previous: Record<string, BasicPrimitive | object>) => Record<string, BasicPrimitive | object>;
configs?: Partial<FlagConfig>[];
negative?: boolean;
multiple?: boolean;
description: string;
describe?: string;
negatedDescription?: string;
defaultValue?: string;
}
interface WebpackCLIBuiltInOption extends WebpackCLIBuiltInFlag {
hidden?: boolean;
group?: "core";
helpLevel?: "minimum" | "verbose";
}
declare type WebpackCLIExternalCommandInfo = Pick<WebpackCLIOptions, "name" | "alias" | "description"> & {
pkg: string;
};
/**
* Webpack dev server
*/
declare type WebpackDevServerOptions = DevServerConfig & WebpackConfiguration & ClientConfiguration & AssetEmittedInfo & WebpackOptionsNormalized & FileCacheOptions & Argv & {
nodeEnv?: "string";
watchOptionsStdin?: boolean;
progress?: boolean | "profile" | undefined;
analyze?: boolean;
prefetch?: string;
json?: boolean;
entry: EntryOptions;
merge?: boolean;
config: string[];
configName?: string[];
disableInterpret?: boolean;
argv: Argv;
};
declare type Callback<T extends unknown[]> = (...args: T) => void;
/**
* Webpack
*/
declare type WebpackConfiguration = Configuration;
declare type ConfigOptions = PotentialPromise<WebpackConfiguration | CallableOption>;
declare type CallableOption = (env: Env | undefined, argv: Argv) => WebpackConfiguration;
declare type WebpackCompiler = Compiler | MultiCompiler;
declare type FlagType = boolean | "enum" | "string" | "path" | "number" | "boolean" | "RegExp" | "reset";
declare type FlagConfig = {
negatedDescription: string;
type: FlagType;
values: FlagType[];
};
declare type FileSystemCacheOptions = WebpackConfiguration & {
cache: FileCacheOptions & {
defaultConfig: string[];
};
};
declare type ProcessedArguments = Record<string, BasicPrimitive | RegExp | (BasicPrimitive | RegExp)[]>;
declare type MultipleCompilerStatsOptions = StatsOptions & {
children: StatsOptions[];
};
declare type CommandAction = Parameters<WebpackCLICommand["action"]>[0];
interface WebpackRunOptions extends WebpackOptionsNormalized {
json?: boolean;
argv?: Argv;
env: Env;
failOnWarnings?: boolean;
}
/**
* Package management
*/
declare type PackageManager = "pnpm" | "yarn" | "npm";
interface PackageInstallOptions {
preMessage?: () => void;
}
interface BasicPackageJsonContent {
name: string;
version: string;
description: string;
license: string;
}
/**
* Plugins and util types
*/
interface CLIPluginOptions {
configPath?: string;
helpfulOutput: boolean;
hot?: boolean | "only";
progress?: boolean | "profile";
prefetch?: string;
analyze?: boolean;
}
declare type BasicPrimitive = string | boolean | number;
declare type Instantiable<InstanceType = unknown, ConstructorParameters extends unknown[] = unknown[]> = {
new (...args: ConstructorParameters): InstanceType;
};
declare type PotentialPromise<T> = T | Promise<T>;
declare type ModuleName = string;
declare type Path = string;
declare type LogHandler = (value: any) => void;
declare type StringFormatter = (value: string) => string;
interface Argv extends Record<string, any> {
env?: Env;
}
interface Env {
WEBPACK_BUNDLE?: boolean;
WEBPACK_BUILD?: boolean;
WEBPACK_WATCH?: boolean;
WEBPACK_SERVE?: boolean;
WEBPACK_PACKAGE?: string;
WEBPACK_DEV_SERVER_PACKAGE?: string;
}
declare type DynamicImport<T> = (url: string) => Promise<{
default: T;
}>;
interface ImportLoaderError extends Error {
code?: string;
}
/**
* External libraries types
*/
declare type OptionConstructor = new (flags: string, description?: string) => Option;
declare type CommanderOption = InstanceType<OptionConstructor>;
interface Rechoir {
prepare: typeof prepare;
}
interface JsonExt {
stringifyStream: typeof stringifyStream;
}
interface RechoirError extends Error {
failures: RechoirError[];
error: Error;
}
interface PromptOptions {
message: string;
defaultResponse: string;
stream: NodeJS.WritableStream;
}
export { IWebpackCLI, WebpackCLICommandOption, WebpackCLIBuiltInOption, WebpackCLIBuiltInFlag, WebpackCLIColors, WebpackCLIStats, WebpackCLIConfig, WebpackCLIExternalCommandInfo, WebpackCLIOptions, WebpackCLICommand, WebpackCLICommandOptions, WebpackCLIMainOption, WebpackCLILogger, WebpackDevServerOptions, WebpackRunOptions, WebpackCompiler, WebpackConfiguration, Argv, Argument, BasicPrimitive, BasicPackageJsonContent, CallableOption, Callback, CLIPluginOptions, CommandAction, CommanderOption, CommandOptions, ConfigOptions, DynamicImport, FileSystemCacheOptions, FlagConfig, ImportLoaderError, Instantiable, JsonExt, ModuleName, MultipleCompilerStatsOptions, PackageInstallOptions, PackageManager, Path, ProcessedArguments, PromptOptions, Problem, PotentialPromise, Rechoir, RechoirError, };
|