@umijs/bundler-webpack 4.0.0-beta.9 → 4.0.0-rc.3

package/compiled/terser-webpack-plugin/jest-worker/build/types.d.ts

@@ -86,6 +86,7 @@ export declare type WorkerOptions = {
     setupArgs: Array<unknown>;
     maxRetries: number;
     workerId: number;
+    workerData?: unknown;
     workerPath: string;
 };
 export declare type MessagePort = typeof EventEmitter & {

package/compiled/terser-webpack-plugin/minify.js

@@ -34,10 +34,17 @@ async function transform(options) {
   // 'use strict' => this === undefined (Clean Scope)
   // Safer for possible security issues, albeit not critical at all here
   // eslint-disable-next-line no-param-reassign
-  const evaluatedOptions = // eslint-disable-next-line no-new-func
+  const evaluatedOptions =
+  /**
+   * @template T
+   * @type {import("./index.js").InternalOptions<T>}
+   * */
+  // eslint-disable-next-line no-new-func
   new Function("exports", "require", "module", "__filename", "__dirname", `'use strict'\nreturn ${options}`)(exports, require, module, __filename, __dirname);
   return minify(evaluatedOptions);
 }
 
-module.exports.minify = minify;
-module.exports.transform = transform;
+module.exports = {
+  minify,
+  transform
+};

package/compiled/terser-webpack-plugin/package.json

@@ -1 +1 @@
-{"name":"terser-webpack-plugin","author":"webpack Contrib Team","license":"MIT","types":"types/cjs.d.ts"}
+{"name":"terser-webpack-plugin","author":"webpack Contrib Team","license":"MIT","types":"types/index.d.ts"}

package/compiled/terser-webpack-plugin/types/index.d.ts

@@ -1,106 +1,4 @@
-export default TerserPlugin;
-export type Schema = import('../schema-utils/declarations/validate').Schema;
-export type Compiler = import('../../webpack').Compiler;
-export type Compilation = import('../../webpack').Compilation;
-export type WebpackError = import('../../webpack').WebpackError;
-export type Asset = import('../../webpack').Asset;
-export type TerserECMA = import('./utils').TerserECMA;
-export type TerserOptions = import('./utils').TerserOptions;
-export type CustomOptions = import('./utils').CustomOptions;
-export type JestWorker = import('../jest-worker').Worker;
-export type RawSourceMap = import('../source-map').RawSourceMap;
-export type Rule = RegExp | string;
-export type Rules = Rule[] | Rule;
-export type ExtractCommentsFunction = (
-  astNode: any,
-  comment: {
-    value: string;
-    type: "comment1" | "comment2" | "comment3" | "comment4";
-    pos: number;
-    line: number;
-    col: number;
-  }
-) => boolean;
-export type ExtractCommentsCondition =
-  | boolean
-  | "all"
-  | "some"
-  | RegExp
-  | ExtractCommentsFunction;
-export type ExtractCommentsFilename = string | ((fileData: any) => string);
-export type ExtractCommentsBanner =
-  | string
-  | boolean
-  | ((commentsFile: string) => string);
-export type ExtractCommentsObject = {
-  condition?: ExtractCommentsCondition | undefined;
-  filename?: ExtractCommentsFilename | undefined;
-  banner?: ExtractCommentsBanner | undefined;
-};
-export type ExtractCommentsOptions =
-  | ExtractCommentsCondition
-  | ExtractCommentsObject;
-export type Input = {
-  [file: string]: string;
-};
-export type MinimizedResult = {
-  code: string;
-  map?: import('../source-map').RawSourceMap | undefined;
-  errors?: (string | Error)[] | undefined;
-  warnings?: (string | Error)[] | undefined;
-  extractedComments?: string[] | undefined;
-};
-export type PredefinedOptions = {
-  module?: boolean | undefined;
-  ecma?: any;
-};
-export type MinimizerImplementationAndOptions<T> = {
-  implementation: MinimizerImplementation<T>;
-  options: PredefinedOptions & T;
-};
-export type InternalOptions<T> = {
-  name: string;
-  input: string;
-  inputSourceMap: RawSourceMap | undefined;
-  extractComments: ExtractCommentsOptions | undefined;
-  minimizer: MinimizerImplementationAndOptions<T>;
-};
-export type MinimizerWorker<T> = Worker & {
-  transform: (options: string) => MinimizedResult;
-  minify: (options: InternalOptions<T>) => MinimizedResult;
-};
-export type BasicMinimizerImplementation<T> = (
-  input: Input,
-  sourceMap: RawSourceMap | undefined,
-  minifyOptions: T,
-  extractComments: ExtractCommentsOptions | undefined
-) => Promise<MinimizedResult>;
-export type MinimizeFunctionHelpers = {
-  getMinimizerVersion?: (() => string | undefined) | undefined;
-};
-export type MinimizerImplementation<T> = BasicMinimizerImplementation<T> &
-  MinimizeFunctionHelpers;
-export type Parallel = undefined | boolean | number;
-export type BasePluginOptions = {
-  test?: Rules | undefined;
-  include?: Rules | undefined;
-  exclude?: Rules | undefined;
-  extractComments?: ExtractCommentsOptions | undefined;
-  parallel?: Parallel;
-};
-export type InferDefaultType<T> = T extends infer U
-  ? U
-  : import('./utils').CustomOptions;
-export type DefinedDefaultMinimizerAndOptions<T> =
-  InferDefaultType<T> extends TerserOptions
-    ? {
-        minify?: MinimizerImplementation<InferDefaultType<T>> | undefined;
-        terserOptions?: InferDefaultType<T> | undefined;
-      }
-    : {
-        minify: MinimizerImplementation<InferDefaultType<T>>;
-        terserOptions?: InferDefaultType<T> | undefined;
-      };
+export = TerserPlugin;
 /** @typedef {import('../schema-utils/declarations/validate').Schema} Schema */
 /** @typedef {import('../../webpack').Compiler} Compiler */
 /** @typedef {import('../../webpack').Compilation} Compilation */
@@ -108,7 +6,6 @@ export type DefinedDefaultMinimizerAndOptions<T> =
 /** @typedef {import('../../webpack').Asset} Asset */
 /** @typedef {import('./utils').TerserECMA} TerserECMA */
 /** @typedef {import('./utils').TerserOptions} TerserOptions */
-/** @typedef {import('./utils').CustomOptions} CustomOptions */
 /** @typedef {import('../jest-worker').Worker} JestWorker */
 /** @typedef {import('../source-map').RawSourceMap} RawSourceMap */
 /** @typedef {RegExp | string} Rule */
@@ -137,9 +34,6 @@ export type DefinedDefaultMinimizerAndOptions<T> =
 /**
  * @typedef {ExtractCommentsCondition | ExtractCommentsObject} ExtractCommentsOptions
  */
-/**
- * @typedef {{ [file: string]: string }} Input
- */
 /**
  * @typedef {Object} MinimizedResult
  * @property {string} code
@@ -149,35 +43,30 @@ export type DefinedDefaultMinimizerAndOptions<T> =
  * @property {Array<string>} [extractedComments]
  */
 /**
- * @typedef {Object} PredefinedOptions
- * @property {boolean} [module]
- * @property {any} [ecma]
+ * @typedef {{ [file: string]: string }} Input
  */
 /**
- * @template T
- * @typedef {Object} MinimizerImplementationAndOptions
- * @property {MinimizerImplementation<T>} implementation
- * @property {PredefinedOptions & T} options
+ * @typedef {{ [key: string]: any }} CustomOptions
  */
 /**
  * @template T
- * @typedef {Object} InternalOptions
- * @property {string} name
- * @property {string} input
- * @property {RawSourceMap | undefined} inputSourceMap
- * @property {ExtractCommentsOptions | undefined} extractComments
- * @property {MinimizerImplementationAndOptions<T>} minimizer
+ * @typedef {T extends infer U ? U : CustomOptions} InferDefaultType
+ */
+/**
+ * @typedef {Object} PredefinedOptions
+ * @property {boolean} [module]
+ * @property {TerserECMA} [ecma]
  */
 /**
  * @template T
- * @typedef {JestWorker & { transform: (options: string) => MinimizedResult, minify: (options: InternalOptions<T>) => MinimizedResult }} MinimizerWorker
+ * @typedef {PredefinedOptions & InferDefaultType<T>} MinimizerOptions
  */
 /**
  * @template T
  * @callback BasicMinimizerImplementation
  * @param {Input} input
  * @param {RawSourceMap | undefined} sourceMap
- * @param {T} minifyOptions
+ * @param {MinimizerOptions<T>} minifyOptions
  * @param {ExtractCommentsOptions | undefined} extractComments
  * @returns {Promise<MinimizedResult>}
  */
@@ -187,7 +76,20 @@ export type DefinedDefaultMinimizerAndOptions<T> =
  */
 /**
  * @template T
- * @typedef {BasicMinimizerImplementation<T> & MinimizeFunctionHelpers } MinimizerImplementation
+ * @typedef {BasicMinimizerImplementation<T> & MinimizeFunctionHelpers} MinimizerImplementation
+ */
+/**
+ * @template T
+ * @typedef {Object} InternalOptions
+ * @property {string} name
+ * @property {string} input
+ * @property {RawSourceMap | undefined} inputSourceMap
+ * @property {ExtractCommentsOptions | undefined} extractComments
+ * @property {{ implementation: MinimizerImplementation<T>, options: MinimizerOptions<T> }} minimizer
+ */
+/**
+ * @template T
+ * @typedef {JestWorker & { transform: (options: string) => MinimizedResult, minify: (options: InternalOptions<T>) => MinimizedResult }} MinimizerWorker
  */
 /**
  * @typedef {undefined | boolean | number} Parallel
@@ -202,16 +104,16 @@ export type DefinedDefaultMinimizerAndOptions<T> =
  */
 /**
  * @template T
- * @typedef {T extends infer U ? U : CustomOptions} InferDefaultType
+ * @typedef {T extends TerserOptions ? { minify?: MinimizerImplementation<T> | undefined, terserOptions?: MinimizerOptions<T> | undefined } : { minify: MinimizerImplementation<T>, terserOptions?: MinimizerOptions<T> | undefined }} DefinedDefaultMinimizerAndOptions
  */
 /**
  * @template T
- * @typedef {InferDefaultType<T> extends TerserOptions ? { minify?: MinimizerImplementation<InferDefaultType<T>> | undefined, terserOptions?: InferDefaultType<T> | undefined } : { minify: MinimizerImplementation<InferDefaultType<T>>, terserOptions?: InferDefaultType<T> | undefined }} DefinedDefaultMinimizerAndOptions
+ * @typedef {BasePluginOptions & { minimizer: { implementation: MinimizerImplementation<T>, options: MinimizerOptions<T> } }} InternalPluginOptions
  */
 /**
- * @template T
+ * @template [T=TerserOptions]
  */
-declare class TerserPlugin<T = TerserOptions> {
+declare class TerserPlugin<T = import('../../terser').MinifyOptions> {
   /**
    * @private
    * @param {any} input
@@ -220,18 +122,18 @@ declare class TerserPlugin<T = TerserOptions> {
   private static isSourceMap;
   /**
    * @private
-   * @param {Error | string} warning
+   * @param {unknown} warning
    * @param {string} file
-   * @returns {WebpackError}
+   * @returns {Error}
    */
   private static buildWarning;
   /**
    * @private
    * @param {any} error
    * @param {string} file
-   * @param {Compilation["requestShortener"]} [requestShortener]
    * @param {SourceMapConsumer} [sourceMap]
-   * @returns {WebpackError}
+   * @param {Compilation["requestShortener"]} [requestShortener]
+   * @returns {Error}
    */
   private static buildError;
   /**
@@ -254,19 +156,11 @@ declare class TerserPlugin<T = TerserOptions> {
       | (BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>)
       | undefined
   );
-  options: {
-    test: Rules;
-    extractComments: ExtractCommentsOptions;
-    parallel: number | boolean;
-    include: Rules | undefined;
-    exclude: Rules | undefined;
-    minimizer: {
-      implementation: MinimizerImplementation<
-        import('../../terser').MinifyOptions & InferDefaultType<T>
-      >;
-      options: InferDefaultType<T>;
-    };
-  };
+  /**
+   * @private
+   * @type {InternalPluginOptions<T>}
+   */
+  private options;
   /**
    * @private
    * @param {Compiler} compiler
@@ -283,13 +177,153 @@ declare class TerserPlugin<T = TerserOptions> {
   apply(compiler: Compiler): void;
 }
 declare namespace TerserPlugin {
-  export { terserMinify };
-  export { uglifyJsMinify };
-  export { swcMinify };
-  export { esbuildMinify };
+  export {
+    terserMinify,
+    uglifyJsMinify,
+    swcMinify,
+    esbuildMinify,
+    Schema,
+    Compiler,
+    Compilation,
+    WebpackError,
+    Asset,
+    TerserECMA,
+    TerserOptions,
+    JestWorker,
+    RawSourceMap,
+    Rule,
+    Rules,
+    ExtractCommentsFunction,
+    ExtractCommentsCondition,
+    ExtractCommentsFilename,
+    ExtractCommentsBanner,
+    ExtractCommentsObject,
+    ExtractCommentsOptions,
+    MinimizedResult,
+    Input,
+    CustomOptions,
+    InferDefaultType,
+    PredefinedOptions,
+    MinimizerOptions,
+    BasicMinimizerImplementation,
+    MinimizeFunctionHelpers,
+    MinimizerImplementation,
+    InternalOptions,
+    MinimizerWorker,
+    Parallel,
+    BasePluginOptions,
+    DefinedDefaultMinimizerAndOptions,
+    InternalPluginOptions,
+  };
 }
-import { Worker } from '../jest-worker';
+type Compiler = import('../../webpack').Compiler;
+type BasePluginOptions = {
+  test?: Rules | undefined;
+  include?: Rules | undefined;
+  exclude?: Rules | undefined;
+  extractComments?: ExtractCommentsOptions | undefined;
+  parallel?: Parallel;
+};
+type DefinedDefaultMinimizerAndOptions<T> = T extends TerserOptions
+  ? {
+      minify?: MinimizerImplementation<T> | undefined;
+      terserOptions?: MinimizerOptions<T> | undefined;
+    }
+  : {
+      minify: MinimizerImplementation<T>;
+      terserOptions?: MinimizerOptions<T> | undefined;
+    };
 import { terserMinify } from './utils';
 import { uglifyJsMinify } from './utils';
 import { swcMinify } from './utils';
 import { esbuildMinify } from './utils';
+type Schema = import('../schema-utils/declarations/validate').Schema;
+type Compilation = import('../../webpack').Compilation;
+type WebpackError = import('../../webpack').WebpackError;
+type Asset = import('../../webpack').Asset;
+type TerserECMA = import('./utils').TerserECMA;
+type TerserOptions = import('./utils').TerserOptions;
+type JestWorker = import('../jest-worker').Worker;
+type RawSourceMap = import('../source-map').RawSourceMap;
+type Rule = RegExp | string;
+type Rules = Rule[] | Rule;
+type ExtractCommentsFunction = (
+  astNode: any,
+  comment: {
+    value: string;
+    type: "comment1" | "comment2" | "comment3" | "comment4";
+    pos: number;
+    line: number;
+    col: number;
+  }
+) => boolean;
+type ExtractCommentsCondition =
+  | boolean
+  | "all"
+  | "some"
+  | RegExp
+  | ExtractCommentsFunction;
+type ExtractCommentsFilename = string | ((fileData: any) => string);
+type ExtractCommentsBanner =
+  | string
+  | boolean
+  | ((commentsFile: string) => string);
+type ExtractCommentsObject = {
+  condition?: ExtractCommentsCondition | undefined;
+  filename?: ExtractCommentsFilename | undefined;
+  banner?: ExtractCommentsBanner | undefined;
+};
+type ExtractCommentsOptions = ExtractCommentsCondition | ExtractCommentsObject;
+type MinimizedResult = {
+  code: string;
+  map?: import('../source-map').RawSourceMap | undefined;
+  errors?: (string | Error)[] | undefined;
+  warnings?: (string | Error)[] | undefined;
+  extractedComments?: string[] | undefined;
+};
+type Input = {
+  [file: string]: string;
+};
+type CustomOptions = {
+  [key: string]: any;
+};
+type InferDefaultType<T> = T extends infer U ? U : CustomOptions;
+type PredefinedOptions = {
+  module?: boolean | undefined;
+  ecma?: import('../../terser').ECMA | undefined;
+};
+type MinimizerOptions<T> = PredefinedOptions & InferDefaultType<T>;
+type BasicMinimizerImplementation<T> = (
+  input: Input,
+  sourceMap: RawSourceMap | undefined,
+  minifyOptions: MinimizerOptions<T>,
+  extractComments: ExtractCommentsOptions | undefined
+) => Promise<MinimizedResult>;
+type MinimizeFunctionHelpers = {
+  getMinimizerVersion?: (() => string | undefined) | undefined;
+};
+type MinimizerImplementation<T> = BasicMinimizerImplementation<T> &
+  MinimizeFunctionHelpers;
+type InternalOptions<T> = {
+  name: string;
+  input: string;
+  inputSourceMap: RawSourceMap | undefined;
+  extractComments: ExtractCommentsOptions | undefined;
+  minimizer: {
+    implementation: MinimizerImplementation<T>;
+    options: MinimizerOptions<T>;
+  };
+};
+type MinimizerWorker<T> = Worker & {
+  transform: (options: string) => MinimizedResult;
+  minify: (options: InternalOptions<T>) => MinimizedResult;
+};
+type Parallel = undefined | boolean | number;
+type InternalPluginOptions<T> = BasePluginOptions & {
+  minimizer: {
+    implementation: MinimizerImplementation<T>;
+    options: MinimizerOptions<T>;
+  };
+};
+import { minify } from './minify';
+import { Worker } from '../jest-worker';

package/compiled/terser-webpack-plugin/types/minify.d.ts

@@ -0,0 +1,17 @@
+export type MinimizedResult = import('./index').MinimizedResult;
+export type CustomOptions = import('./index').CustomOptions;
+/** @typedef {import('./index').MinimizedResult} MinimizedResult */
+/** @typedef {import('./index').CustomOptions} CustomOptions */
+/**
+ * @template T
+ * @param {import('./index').InternalOptions<T>} options
+ * @returns {Promise<MinimizedResult>}
+ */
+export function minify<T>(
+  options: import('./index').InternalOptions<T>
+): Promise<MinimizedResult>;
+/**
+ * @param {string} options
+ * @returns {Promise<MinimizedResult>}
+ */
+export function transform(options: string): Promise<MinimizedResult>;

package/compiled/terser-webpack-plugin/types/utils.d.ts

@@ -1,3 +1,4 @@
+export type Task<T> = () => Promise<T>;
 export type RawSourceMap = import('../source-map').RawSourceMap;
 export type TerserFormatOptions = import('../../terser').FormatOptions;
 export type TerserOptions = import('../../terser').MinifyOptions;
@@ -11,26 +12,20 @@ export type ExtractCommentsCondition =
 export type Input = import('./index').Input;
 export type MinimizedResult = import('./index').MinimizedResult;
 export type PredefinedOptions = import('./index').PredefinedOptions;
-export type CustomOptions = {
-  [key: string]: any;
-};
+export type CustomOptions = import('./index').CustomOptions;
 export type ExtractedComments = Array<string>;
-/** @typedef {import('../source-map').RawSourceMap} RawSourceMap */
-/** @typedef {import('../../terser').FormatOptions} TerserFormatOptions */
-/** @typedef {import('../../terser').MinifyOptions} TerserOptions */
-/** @typedef {import('../../terser').ECMA} TerserECMA */
-/** @typedef {import('./index').ExtractCommentsOptions} ExtractCommentsOptions */
-/** @typedef {import('./index').ExtractCommentsFunction} ExtractCommentsFunction */
-/** @typedef {import('./index').ExtractCommentsCondition} ExtractCommentsCondition */
-/** @typedef {import('./index').Input} Input */
-/** @typedef {import('./index').MinimizedResult} MinimizedResult */
-/** @typedef {import('./index').PredefinedOptions} PredefinedOptions */
 /**
- * @typedef {{ [key: string]: any }} CustomOptions
+ * @template T
+ * @typedef {() => Promise<T>} Task
  */
 /**
- * @typedef {Array<string>} ExtractedComments
+ * Run tasks with limited concurency.
+ * @template T
+ * @param {number} limit - Limit of tasks that run at once.
+ * @param {Task<T>[]} tasks - List of tasks to run.
+ * @returns {Promise<T[]>} A promise that fulfills to an array of the results
  */
+export function throttleAll<T>(limit: number, tasks: Task<T>[]): Promise<T[]>;
 /**
  * @param {Input} input
  * @param {RawSourceMap | undefined} sourceMap