@umijs/bundler-webpack 3.5.20 → 4.0.0-beta.12

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

@@ -0,0 +1,690 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.esbuildMinify = esbuildMinify;
+exports.swcMinify = swcMinify;
+exports.terserMinify = terserMinify;
+exports.throttleAll = throttleAll;
+exports.uglifyJsMinify = uglifyJsMinify;
+
+/** @typedef {import("source-map").RawSourceMap} RawSourceMap */
+
+/** @typedef {import("terser").FormatOptions} TerserFormatOptions */
+
+/** @typedef {import("terser").MinifyOptions} TerserOptions */
+
+/** @typedef {import("terser").ECMA} TerserECMA */
+
+/** @typedef {import("./index.js").ExtractCommentsOptions} ExtractCommentsOptions */
+
+/** @typedef {import("./index.js").ExtractCommentsFunction} ExtractCommentsFunction */
+
+/** @typedef {import("./index.js").ExtractCommentsCondition} ExtractCommentsCondition */
+
+/** @typedef {import("./index.js").Input} Input */
+
+/** @typedef {import("./index.js").MinimizedResult} MinimizedResult */
+
+/** @typedef {import("./index.js").PredefinedOptions} PredefinedOptions */
+
+/**
+ * @typedef {{ [key: string]: any }} CustomOptions
+ */
+
+/**
+ * @typedef {Array<string>} ExtractedComments
+ */
+const notSettled = Symbol(`not-settled`);
+/**
+ * @template T
+ * @typedef {() => Promise<T>} Task
+ */
+
+/**
+ * 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
+ */
+
+function throttleAll(limit, tasks) {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new TypeError(`Expected \`limit\` to be a finite number > 0, got \`${limit}\` (${typeof limit})`);
+  }
+
+  if (!Array.isArray(tasks) || !tasks.every(task => typeof task === `function`)) {
+    throw new TypeError(`Expected \`tasks\` to be a list of functions returning a promise`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const result = Array(tasks.length).fill(notSettled);
+    const entries = tasks.entries();
+
+    const next = () => {
+      const {
+        done,
+        value
+      } = entries.next();
+
+      if (done) {
+        const isLast = !result.includes(notSettled);
+        if (isLast) resolve(
+        /** @type{T[]} **/
+        result);
+        return;
+      }
+
+      const [index, task] = value;
+      /**
+       * @param {T} x
+       */
+
+      const onFulfilled = x => {
+        result[index] = x;
+        next();
+      };
+
+      task().then(onFulfilled, reject);
+    };
+
+    Array(limit).fill(0).forEach(next);
+  });
+}
+/* istanbul ignore next */
+
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {PredefinedOptions & CustomOptions} minimizerOptions
+ * @param {ExtractCommentsOptions | undefined} extractComments
+ * @return {Promise<MinimizedResult>}
+ */
+
+
+async function terserMinify(input, sourceMap, minimizerOptions, extractComments) {
+  /**
+   * @param {any} value
+   * @returns {boolean}
+   */
+  const isObject = value => {
+    const type = typeof value;
+    return value != null && (type === "object" || type === "function");
+  };
+  /**
+   * @param {TerserOptions & { sourceMap: undefined } & ({ output: TerserFormatOptions & { beautify: boolean } } | { format: TerserFormatOptions & { beautify: boolean } })} terserOptions
+   * @param {ExtractedComments} extractedComments
+   * @returns {ExtractCommentsFunction}
+   */
+
+
+  const buildComments = (terserOptions, extractedComments) => {
+    /** @type {{ [index: string]: ExtractCommentsCondition }} */
+    const condition = {};
+    let comments;
+
+    if (terserOptions.format) {
+      ({
+        comments
+      } = terserOptions.format);
+    } else if (terserOptions.output) {
+      ({
+        comments
+      } = terserOptions.output);
+    }
+
+    condition.preserve = typeof comments !== "undefined" ? comments : false;
+
+    if (typeof extractComments === "boolean" && extractComments) {
+      condition.extract = "some";
+    } else if (typeof extractComments === "string" || extractComments instanceof RegExp) {
+      condition.extract = extractComments;
+    } else if (typeof extractComments === "function") {
+      condition.extract = extractComments;
+    } else if (extractComments && isObject(extractComments)) {
+      condition.extract = typeof extractComments.condition === "boolean" && extractComments.condition ? "some" : typeof extractComments.condition !== "undefined" ? extractComments.condition : "some";
+    } else {
+      // No extract
+      // Preserve using "commentsOpts" or "some"
+      condition.preserve = typeof comments !== "undefined" ? comments : "some";
+      condition.extract = false;
+    } // Ensure that both conditions are functions
+
+
+    ["preserve", "extract"].forEach(key => {
+      /** @type {undefined | string} */
+      let regexStr;
+      /** @type {undefined | RegExp} */
+
+      let regex;
+
+      switch (typeof condition[key]) {
+        case "boolean":
+          condition[key] = condition[key] ? () => true : () => false;
+          break;
+
+        case "function":
+          break;
+
+        case "string":
+          if (condition[key] === "all") {
+            condition[key] = () => true;
+
+            break;
+          }
+
+          if (condition[key] === "some") {
+            condition[key] =
+            /** @type {ExtractCommentsFunction} */
+            (astNode, comment) => (comment.type === "comment2" || comment.type === "comment1") && /@preserve|@lic|@cc_on|^\**!/i.test(comment.value);
+
+            break;
+          }
+
+          regexStr =
+          /** @type {string} */
+          condition[key];
+
+          condition[key] =
+          /** @type {ExtractCommentsFunction} */
+          (astNode, comment) => new RegExp(
+          /** @type {string} */
+          regexStr).test(comment.value);
+
+          break;
+
+        default:
+          regex =
+          /** @type {RegExp} */
+          condition[key];
+
+          condition[key] =
+          /** @type {ExtractCommentsFunction} */
+          (astNode, comment) =>
+          /** @type {RegExp} */
+          regex.test(comment.value);
+
+      }
+    }); // Redefine the comments function to extract and preserve
+    // comments according to the two conditions
+
+    return (astNode, comment) => {
+      if (
+      /** @type {{ extract: ExtractCommentsFunction }} */
+      condition.extract(astNode, comment)) {
+        const commentText = comment.type === "comment2" ? `/*${comment.value}*/` : `//${comment.value}`; // Don't include duplicate comments
+
+        if (!extractedComments.includes(commentText)) {
+          extractedComments.push(commentText);
+        }
+      }
+
+      return (
+        /** @type {{ preserve: ExtractCommentsFunction }} */
+        condition.preserve(astNode, comment)
+      );
+    };
+  };
+  /**
+   * @param {PredefinedOptions & TerserOptions} [terserOptions={}]
+   * @returns {TerserOptions & { sourceMap: undefined } & ({ output: TerserFormatOptions & { beautify: boolean } } | { format: TerserFormatOptions & { beautify: boolean } })}
+   */
+
+
+  const buildTerserOptions = (terserOptions = {}) => {
+    // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+    return { ...terserOptions,
+      compress: typeof terserOptions.compress === "boolean" ? terserOptions.compress : { ...terserOptions.compress
+      },
+      // ecma: terserOptions.ecma,
+      // ie8: terserOptions.ie8,
+      // keep_classnames: terserOptions.keep_classnames,
+      // keep_fnames: terserOptions.keep_fnames,
+      mangle: terserOptions.mangle == null ? true : typeof terserOptions.mangle === "boolean" ? terserOptions.mangle : { ...terserOptions.mangle
+      },
+      // module: terserOptions.module,
+      // nameCache: { ...terserOptions.toplevel },
+      // the `output` option is deprecated
+      ...(terserOptions.format ? {
+        format: {
+          beautify: false,
+          ...terserOptions.format
+        }
+      } : {
+        output: {
+          beautify: false,
+          ...terserOptions.output
+        }
+      }),
+      parse: { ...terserOptions.parse
+      },
+      // safari10: terserOptions.safari10,
+      // Ignoring sourceMap from options
+      // eslint-disable-next-line no-undefined
+      sourceMap: undefined // toplevel: terserOptions.toplevel
+
+    };
+  }; // eslint-disable-next-line global-require
+
+
+  const {
+    minify
+  } = require('@umijs/bundler-webpack/compiled/terser'); // Copy `terser` options
+
+
+  const terserOptions = buildTerserOptions(minimizerOptions); // Let terser generate a SourceMap
+
+  if (sourceMap) {
+    // @ts-ignore
+    terserOptions.sourceMap = {
+      asObject: true
+    };
+  }
+  /** @type {ExtractedComments} */
+
+
+  const extractedComments = [];
+
+  if (terserOptions.output) {
+    terserOptions.output.comments = buildComments(terserOptions, extractedComments);
+  } else if (terserOptions.format) {
+    terserOptions.format.comments = buildComments(terserOptions, extractedComments);
+  }
+
+  const [[filename, code]] = Object.entries(input);
+  const result = await minify({
+    [filename]: code
+  }, terserOptions);
+  return {
+    code:
+    /** @type {string} **/
+    result.code,
+    // @ts-ignore
+    // eslint-disable-next-line no-undefined
+    map: result.map ?
+    /** @type {RawSourceMap} **/
+    result.map : undefined,
+    extractedComments
+  };
+}
+/**
+ * @returns {string | undefined}
+ */
+
+
+terserMinify.getMinimizerVersion = () => {
+  let packageJson;
+
+  try {
+    // eslint-disable-next-line global-require
+    packageJson = require('@umijs/bundler-webpack/compiled/terser/package.json');
+  } catch (error) {// Ignore
+  }
+
+  return packageJson && packageJson.version;
+};
+/* istanbul ignore next */
+
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {PredefinedOptions & CustomOptions} minimizerOptions
+ * @param {ExtractCommentsOptions | undefined} extractComments
+ * @return {Promise<MinimizedResult>}
+ */
+
+
+async function uglifyJsMinify(input, sourceMap, minimizerOptions, extractComments) {
+  /**
+   * @param {any} value
+   * @returns {boolean}
+   */
+  const isObject = value => {
+    const type = typeof value;
+    return value != null && (type === "object" || type === "function");
+  };
+  /**
+   * @param {import("uglify-js").MinifyOptions & { sourceMap: undefined } & { output: import("uglify-js").OutputOptions & { beautify: boolean }}} uglifyJsOptions
+   * @param {ExtractedComments} extractedComments
+   * @returns {ExtractCommentsFunction}
+   */
+
+
+  const buildComments = (uglifyJsOptions, extractedComments) => {
+    /** @type {{ [index: string]: ExtractCommentsCondition }} */
+    const condition = {};
+    const {
+      comments
+    } = uglifyJsOptions.output;
+    condition.preserve = typeof comments !== "undefined" ? comments : false;
+
+    if (typeof extractComments === "boolean" && extractComments) {
+      condition.extract = "some";
+    } else if (typeof extractComments === "string" || extractComments instanceof RegExp) {
+      condition.extract = extractComments;
+    } else if (typeof extractComments === "function") {
+      condition.extract = extractComments;
+    } else if (extractComments && isObject(extractComments)) {
+      condition.extract = typeof extractComments.condition === "boolean" && extractComments.condition ? "some" : typeof extractComments.condition !== "undefined" ? extractComments.condition : "some";
+    } else {
+      // No extract
+      // Preserve using "commentsOpts" or "some"
+      condition.preserve = typeof comments !== "undefined" ? comments : "some";
+      condition.extract = false;
+    } // Ensure that both conditions are functions
+
+
+    ["preserve", "extract"].forEach(key => {
+      /** @type {undefined | string} */
+      let regexStr;
+      /** @type {undefined | RegExp} */
+
+      let regex;
+
+      switch (typeof condition[key]) {
+        case "boolean":
+          condition[key] = condition[key] ? () => true : () => false;
+          break;
+
+        case "function":
+          break;
+
+        case "string":
+          if (condition[key] === "all") {
+            condition[key] = () => true;
+
+            break;
+          }
+
+          if (condition[key] === "some") {
+            condition[key] =
+            /** @type {ExtractCommentsFunction} */
+            (astNode, comment) => (comment.type === "comment2" || comment.type === "comment1") && /@preserve|@lic|@cc_on|^\**!/i.test(comment.value);
+
+            break;
+          }
+
+          regexStr =
+          /** @type {string} */
+          condition[key];
+
+          condition[key] =
+          /** @type {ExtractCommentsFunction} */
+          (astNode, comment) => new RegExp(
+          /** @type {string} */
+          regexStr).test(comment.value);
+
+          break;
+
+        default:
+          regex =
+          /** @type {RegExp} */
+          condition[key];
+
+          condition[key] =
+          /** @type {ExtractCommentsFunction} */
+          (astNode, comment) =>
+          /** @type {RegExp} */
+          regex.test(comment.value);
+
+      }
+    }); // Redefine the comments function to extract and preserve
+    // comments according to the two conditions
+
+    return (astNode, comment) => {
+      if (
+      /** @type {{ extract: ExtractCommentsFunction }} */
+      condition.extract(astNode, comment)) {
+        const commentText = comment.type === "comment2" ? `/*${comment.value}*/` : `//${comment.value}`; // Don't include duplicate comments
+
+        if (!extractedComments.includes(commentText)) {
+          extractedComments.push(commentText);
+        }
+      }
+
+      return (
+        /** @type {{ preserve: ExtractCommentsFunction }} */
+        condition.preserve(astNode, comment)
+      );
+    };
+  };
+  /**
+   * @param {PredefinedOptions & import("uglify-js").MinifyOptions} [uglifyJsOptions={}]
+   * @returns {import("uglify-js").MinifyOptions & { sourceMap: undefined } & { output: import("uglify-js").OutputOptions & { beautify: boolean }}}
+   */
+
+
+  const buildUglifyJsOptions = (uglifyJsOptions = {}) => {
+    // eslint-disable-next-line no-param-reassign
+    delete minimizerOptions.ecma; // eslint-disable-next-line no-param-reassign
+
+    delete minimizerOptions.module; // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+
+    return { ...uglifyJsOptions,
+      // warnings: uglifyJsOptions.warnings,
+      parse: { ...uglifyJsOptions.parse
+      },
+      compress: typeof uglifyJsOptions.compress === "boolean" ? uglifyJsOptions.compress : { ...uglifyJsOptions.compress
+      },
+      mangle: uglifyJsOptions.mangle == null ? true : typeof uglifyJsOptions.mangle === "boolean" ? uglifyJsOptions.mangle : { ...uglifyJsOptions.mangle
+      },
+      output: {
+        beautify: false,
+        ...uglifyJsOptions.output
+      },
+      // Ignoring sourceMap from options
+      // eslint-disable-next-line no-undefined
+      sourceMap: undefined // toplevel: uglifyJsOptions.toplevel
+      // nameCache: { ...uglifyJsOptions.toplevel },
+      // ie8: uglifyJsOptions.ie8,
+      // keep_fnames: uglifyJsOptions.keep_fnames,
+
+    };
+  }; // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+
+
+  const {
+    minify
+  } = require('uglify-js'); // Copy `uglify-js` options
+
+
+  const uglifyJsOptions = buildUglifyJsOptions(minimizerOptions); // Let terser generate a SourceMap
+
+  if (sourceMap) {
+    // @ts-ignore
+    uglifyJsOptions.sourceMap = true;
+  }
+  /** @type {ExtractedComments} */
+
+
+  const extractedComments = []; // @ts-ignore
+
+  uglifyJsOptions.output.comments = buildComments(uglifyJsOptions, extractedComments);
+  const [[filename, code]] = Object.entries(input);
+  const result = await minify({
+    [filename]: code
+  }, uglifyJsOptions);
+  return {
+    code: result.code,
+    // eslint-disable-next-line no-undefined
+    map: result.map ? JSON.parse(result.map) : undefined,
+    errors: result.error ? [result.error] : [],
+    warnings: result.warnings || [],
+    extractedComments
+  };
+}
+/**
+ * @returns {string | undefined}
+ */
+
+
+uglifyJsMinify.getMinimizerVersion = () => {
+  let packageJson;
+
+  try {
+    // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+    packageJson = require('uglify-js/package.json');
+  } catch (error) {// Ignore
+  }
+
+  return packageJson && packageJson.version;
+};
+/* istanbul ignore next */
+
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {PredefinedOptions & CustomOptions} minimizerOptions
+ * @return {Promise<MinimizedResult>}
+ */
+
+
+async function swcMinify(input, sourceMap, minimizerOptions) {
+  /**
+   * @param {PredefinedOptions & import("@swc/core").JsMinifyOptions} [swcOptions={}]
+   * @returns {import("@swc/core").JsMinifyOptions & { sourceMap: undefined }}
+   */
+  const buildSwcOptions = (swcOptions = {}) => {
+    // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+    return { ...swcOptions,
+      compress: typeof swcOptions.compress === "boolean" ? swcOptions.compress : { ...swcOptions.compress
+      },
+      mangle: swcOptions.mangle == null ? true : typeof swcOptions.mangle === "boolean" ? swcOptions.mangle : { ...swcOptions.mangle
+      },
+      // ecma: swcOptions.ecma,
+      // keep_classnames: swcOptions.keep_classnames,
+      // keep_fnames: swcOptions.keep_fnames,
+      // module: swcOptions.module,
+      // safari10: swcOptions.safari10,
+      // toplevel: swcOptions.toplevel
+      // eslint-disable-next-line no-undefined
+      sourceMap: undefined
+    };
+  }; // eslint-disable-next-line import/no-extraneous-dependencies, global-require
+
+
+  const swc = require('@swc/core'); // Copy `swc` options
+
+
+  const swcOptions = buildSwcOptions(minimizerOptions); // Let `swc` generate a SourceMap
+
+  if (sourceMap) {
+    // @ts-ignore
+    swcOptions.sourceMap = true;
+  }
+
+  const [[filename, code]] = Object.entries(input);
+  const result = await swc.minify(code, swcOptions);
+  let map;
+
+  if (result.map) {
+    map = JSON.parse(result.map); // TODO workaround for swc because `filename` is not preset as in `swc` signature as for `terser`
+
+    map.sources = [filename];
+    delete map.sourcesContent;
+  }
+
+  return {
+    code: result.code,
+    map
+  };
+}
+/**
+ * @returns {string | undefined}
+ */
+
+
+swcMinify.getMinimizerVersion = () => {
+  let packageJson;
+
+  try {
+    // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+    packageJson = require('@swc/core/package.json');
+  } catch (error) {// Ignore
+  }
+
+  return packageJson && packageJson.version;
+};
+/* istanbul ignore next */
+
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {PredefinedOptions & CustomOptions} minimizerOptions
+ * @return {Promise<MinimizedResult>}
+ */
+
+
+async function esbuildMinify(input, sourceMap, minimizerOptions) {
+  /**
+   * @param {PredefinedOptions & import("esbuild").TransformOptions} [esbuildOptions={}]
+   * @returns {import("esbuild").TransformOptions}
+   */
+  const buildEsbuildOptions = (esbuildOptions = {}) => {
+    // eslint-disable-next-line no-param-reassign
+    delete esbuildOptions.ecma;
+
+    if (esbuildOptions.module) {
+      // eslint-disable-next-line no-param-reassign
+      esbuildOptions.format = "esm";
+    } // eslint-disable-next-line no-param-reassign
+
+
+    delete esbuildOptions.module; // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+
+    return {
+      minify: true,
+      legalComments: "inline",
+      ...esbuildOptions,
+      sourcemap: false
+    };
+  }; // eslint-disable-next-line import/no-extraneous-dependencies, global-require
+
+
+  const esbuild = require('@umijs/bundler-utils/compiled/esbuild'); // Copy `esbuild` options
+
+
+  const esbuildOptions = buildEsbuildOptions(minimizerOptions); // Let `esbuild` generate a SourceMap
+
+  if (sourceMap) {
+    esbuildOptions.sourcemap = true;
+    esbuildOptions.sourcesContent = false;
+  }
+
+  const [[filename, code]] = Object.entries(input);
+  esbuildOptions.sourcefile = filename;
+  const result = await esbuild.transform(code, esbuildOptions);
+  return {
+    code: result.code,
+    // eslint-disable-next-line no-undefined
+    map: result.map ? JSON.parse(result.map) : undefined,
+    warnings: result.warnings.length > 0 ? result.warnings.map(item => {
+      return {
+        name: "Warning",
+        source: item.location && item.location.file,
+        line: item.location && item.location.line,
+        column: item.location && item.location.column,
+        plugin: item.pluginName,
+        message: `${item.text}${item.detail ? `\nDetails:\n${item.detail}` : ""}${item.notes.length > 0 ? `\n\nNotes:\n${item.notes.map(note => `${note.location ? `[${note.location.file}:${note.location.line}:${note.location.column}] ` : ""}${note.text}${note.location ? `\nSuggestion: ${note.location.suggestion}` : ""}${note.location ? `\nLine text:\n${note.location.lineText}\n` : ""}`).join("\n")}` : ""}`
+      };
+    }) : []
+  };
+}
+/**
+ * @returns {string | undefined}
+ */
+
+
+esbuildMinify.getMinimizerVersion = () => {
+  let packageJson;
+
+  try {
+    // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+    packageJson = require('@umijs/bundler-utils/compiled/esbuild/package.json');
+  } catch (error) {// Ignore
+  }
+
+  return packageJson && packageJson.version;
+};

package/compiled/url-loader/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.