terser-webpack-plugin

cleanCssMinify: typeof cleanCssMinify;

cssnanoMinify: typeof cssnanoMinify;

cssoMinify: typeof cssoMinify;

esbuildMinify: typeof esbuildMinify;

esbuildMinifyCss: typeof esbuildMinifyCss;

htmlMinifierTerser: typeof htmlMinifierTerser;

jsonMinify: typeof jsonMinify;

lightningCssMinify: typeof lightningCssMinify;

minifyHtmlNode: typeof minifyHtmlNode;

swcMinify: typeof swcMinify;

swcMinifyCss: typeof swcMinifyCss;

swcMinifyHtml: typeof swcMinifyHtml;

swcMinifyHtmlFragment: typeof swcMinifyHtmlFragment;

terserMinify: typeof terserMinify;

uglifyJsMinify: typeof uglifyJsMinify;

type Asset = import('webpack').Asset;

type AssetInfo = import('webpack').AssetInfo;

type BasePluginOptions = {
    /**
     * test rule
     */
    test?: Rules | undefined;
    /**
     * include rile
     */
    include?: Rules | undefined;
    /**
     * exclude rule
     */
    exclude?: Rules | undefined;
    /**
     * extract comments options
     */
    extractComments?: ExtractCommentsOptions | undefined;
    /**
     * parallel option
     */
    parallel?: Parallel | undefined;
};

type BasicMinimizerImplementation<T> = (
    input: Input,
    sourceMap: RawSourceMap | undefined,
    minifyOptions: MinimizerOptions<T>,
    extractComments: ExtractCommentsOptions | undefined
) => Promise<MinimizedResult> | MinimizedResult;

type Compilation = import('webpack').Compilation;

type Compiler = import('webpack').Compiler;

type CustomOptions = {
    [key: string]: EXPECTED_ANY;
};

type DefinedDefaultMinimizerAndOptions<T> = T extends import('terser').MinifyOptions
    ? {
          minify?: MinimizerImplementation<T> | undefined;
          minimizerOptions?: MinimizerOptions<T> | undefined;
          terserOptions?: MinimizerOptions<T> | undefined;
      }
    : {
          minify: MinimizerImplementation<T>;
          minimizerOptions?: MinimizerOptions<T> | undefined;
          terserOptions?: MinimizerOptions<T> | undefined;
      };

type ErrorObject = {
    /**
     * message
     */
    message: string;
    /**
     * line number
     */
    line?: number | undefined;
    /**
     * column number
     */
    column?: number | undefined;
    /**
     * error stack trace
     */
    stack?: string | undefined;
};

type EXPECTED_ANY = any;

type EXPECTED_OBJECT = object;

type ExtractCommentsBanner = boolean | string | ((commentsFile: string) => string);

type ExtractCommentsCondition =
    | boolean
    | 'all'
    | 'some'
    | RegExp
    | ExtractCommentsFunction;

type ExtractCommentsFilename = TemplatePath;

type ExtractCommentsFunction = (
    astNode: EXPECTED_ANY,
    comment: {
        value: string;
        type: 'comment1' | 'comment2' | 'comment3' | 'comment4';
        pos: number;
        line: number;
        col: number;
    }
) => boolean;

type ExtractCommentsObject = {
    /**
     * condition which comments need to be expected
     */
    condition?: ExtractCommentsCondition | undefined;
    /**
     * filename for extracted comments
     */
    filename?: ExtractCommentsFilename | undefined;
    /**
     * banner in filename for extracted comments
     */
    banner?: ExtractCommentsBanner | undefined;
};

type ExtractCommentsOptions = ExtractCommentsCondition | ExtractCommentsObject;

type InferDefaultType<T> = T extends infer U ? U : CustomOptions;

type Input = {
    [file: string]: string;
};

type InternalOptions<T> = {
    /**
     * name
     */
    name: string;
    /**
     * input
     */
    input: string;
    /**
     * input source map
     */
    inputSourceMap: RawSourceMap | undefined;
    /**
     * extract comments option
     */
    extractComments: ExtractCommentsOptions | undefined;
    /**
     * minimizer
     */
    minimizer: {
        implementation: MinimizerImplementation<T>;
        options: MinimizerOptions<T>;
    };
    /**
     * true when code is a EC module, otherwise false
     */
    module?: boolean | undefined;
    /**
     * ecma version
     */
    ecma?: (number | string) | undefined;
};

type InternalPluginOptions<T> = BasePluginOptions & {
    minimizer: {
        implementation: MinimizerImplementation<T>;
        options: MinimizerOptions<T>;
    };
};

type JestWorker = import('jest-worker').Worker;

type MinimizedResult = {
    /**
     * code
     */
    code?: string | undefined;
    /**
     * source map
     */
    map?: RawSourceMap | undefined;
    /**
     * errors
     */
    errors?: (Error | string)[] | undefined;
    /**
     * warnings
     */
    warnings?: (Error | string)[] | undefined;
    /**
     * extracted comments
     */
    extractedComments?: string[] | undefined;
};

type MinimizeFunctionHelpers = {
    /**
     * function that returns version of minimizer
     */
    getMinimizerVersion?: (() => string | undefined) | undefined;
    /**
     * true when minimizer support worker threads, otherwise false
     */
    supportsWorkerThreads?: (() => boolean | undefined) | undefined;
    /**
     * true when minimizer support worker, otherwise false
     */
    supportsWorker?: (() => boolean | undefined) | undefined;
    /**
     * return true when the minimizer supports the asset, otherwise false. When an array of minimizers is configured, each asset is dispatched only to the minimizers whose `filter` accepts it. Assets rejected by every minimizer in the array are skipped entirely.
     */
    filter?: ((name: string, info?: AssetInfo) => boolean | undefined) | undefined;
};

type MinimizerImplementation<T> = T extends EXPECTED_ANY[]
    ? {
          [P in keyof T]: BasicMinimizerImplementation<T[P]> &
              MinimizeFunctionHelpers;
      }
    : BasicMinimizerImplementation<T> & MinimizeFunctionHelpers;

type MinimizerOptions<T> = T extends EXPECTED_ANY[]
    ? { [P in keyof T]?: T[P] & InferDefaultType<T[P]> }
    : T & InferDefaultType<T>;

type MinimizerWorker<T> = JestWorker & {
    transform: (options: string) => Promise<MinimizedResult>;
    minify: (options: InternalOptions<T>) => Promise<MinimizedResult>;
};

type Parallel = undefined | boolean | number;

type RawSourceMap = import('@jridgewell/trace-mapping').EncodedSourceMap & {
    sources: string[];
    sourcesContent?: string[];
    file: string;
};

type Rule = RegExp | string;

type Rules = Rule[] | Rule;

type Schema = import('schema-utils/declarations/validate').Schema;

type TemplatePath = import('webpack').TemplatePath;

type TraceMap = import('@jridgewell/trace-mapping').TraceMap;