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

package/compiled/css-minimizer-webpack-plugin/minify.js

@@ -0,0 +1,72 @@
+"use strict";
+
+const minify = async options => {
+  const minifyFns = typeof options.minify === "function" ? [options.minify] : options.minify;
+  const result = {
+    outputs: [],
+    warnings: [],
+    errors: []
+  };
+  let needSourceMap = false;
+
+  for (let i = 0; i <= minifyFns.length - 1; i++) {
+    const minifyFn = minifyFns[i];
+    const minifyOptions = Array.isArray(options.minifyOptions) ? options.minifyOptions[i] : options.minifyOptions;
+    const prevResult = result.outputs.length > 0 ? result.outputs[result.outputs.length - 1] : {
+      code: options.input,
+      map: options.inputSourceMap
+    };
+    const {
+      code,
+      map
+    } = prevResult; // eslint-disable-next-line no-await-in-loop
+
+    const minifyResult = await minifyFn({
+      [options.name]: code
+    }, map, minifyOptions);
+
+    if (typeof minifyResult.code !== "string") {
+      throw new Error("minimizer function doesn't return the 'code' property or result is not a string value");
+    }
+
+    if (minifyResult.map) {
+      needSourceMap = true;
+    }
+
+    if (minifyResult.errors) {
+      result.errors = result.errors.concat(minifyResult.errors);
+    }
+
+    if (minifyResult.warnings) {
+      result.warnings = result.warnings.concat(minifyResult.warnings);
+    }
+
+    result.outputs.push({
+      code: minifyResult.code,
+      map: minifyResult.map
+    });
+  }
+
+  if (!needSourceMap) {
+    result.outputs = [result.outputs[result.outputs.length - 1]];
+  }
+
+  return result;
+};
+
+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-new-func, no-param-reassign
+  const evaluatedOptions = new Function("exports", "require", "module", "__filename", "__dirname", `'use strict'\nreturn ${options}`)(exports, require, module, __filename, __dirname);
+  const result = await minify(evaluatedOptions);
+
+  if (result.error) {
+    throw result.error;
+  } else {
+    return result;
+  }
+}
+
+module.exports.minify = minify;
+module.exports.transform = transform;

package/compiled/css-minimizer-webpack-plugin/package.json

@@ -0,0 +1 @@
+{"name":"css-minimizer-webpack-plugin","author":"Loann Neveu","license":"MIT"}

package/compiled/css-minimizer-webpack-plugin/utils.js

@@ -0,0 +1,166 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cssnanoMinify = cssnanoMinify;
+exports.cssoMinify = cssoMinify;
+exports.cleanCssMinify = cleanCssMinify;
+exports.esbuildMinify = esbuildMinify;
+
+/* istanbul ignore next */
+async function cssnanoMinify(input, inputSourceMap, minimizerOptions = {
+  preset: "default"
+}) {
+  const load = async module => {
+    let exports;
+
+    try {
+      // eslint-disable-next-line import/no-dynamic-require, global-require
+      exports = require(module);
+      return exports;
+    } catch (requireError) {
+      let importESM;
+
+      try {
+        // eslint-disable-next-line no-new-func
+        importESM = new Function("id", "return import(id);");
+      } catch (e) {
+        importESM = null;
+      }
+
+      if (requireError.code === "ERR_REQUIRE_ESM" && importESM) {
+        exports = await importESM(module);
+        return exports.default;
+      }
+
+      throw requireError;
+    }
+  };
+
+  const [[name, code]] = Object.entries(input);
+  const postcssOptions = {
+    to: name,
+    from: name,
+    ...minimizerOptions.processorOptions
+  };
+
+  if (typeof postcssOptions.parser === "string") {
+    try {
+      postcssOptions.parser = await load(postcssOptions.parser);
+    } catch (error) {
+      throw new Error(`Loading PostCSS "${postcssOptions.parser}" parser failed: ${error.message}\n\n(@${name})`);
+    }
+  }
+
+  if (typeof postcssOptions.stringifier === "string") {
+    try {
+      postcssOptions.stringifier = await load(postcssOptions.stringifier);
+    } catch (error) {
+      throw new Error(`Loading PostCSS "${postcssOptions.stringifier}" stringifier failed: ${error.message}\n\n(@${name})`);
+    }
+  }
+
+  if (typeof postcssOptions.syntax === "string") {
+    try {
+      postcssOptions.syntax = await load(postcssOptions.syntax);
+    } catch (error) {
+      throw new Error(`Loading PostCSS "${postcssOptions.syntax}" syntax failed: ${error.message}\n\n(@${name})`);
+    }
+  }
+
+  if (inputSourceMap) {
+    postcssOptions.map = {
+      annotation: false
+    };
+  } // eslint-disable-next-line global-require
+
+
+  const postcss = require('postcss'); // eslint-disable-next-line global-require
+
+
+  const cssnano = require('@umijs/bundler-webpack/compiled/cssnano');
+
+  const result = await postcss([cssnano(minimizerOptions)]).process(code, postcssOptions);
+  return {
+    code: result.css,
+    map: result.map && result.map.toString(),
+    warnings: result.warnings().map(String)
+  };
+}
+/* istanbul ignore next */
+
+
+async function cssoMinify(input, inputSourceMap, minimizerOptions) {
+  // eslint-disable-next-line global-require,import/no-extraneous-dependencies
+  const csso = require("csso");
+
+  const [[filename, code]] = Object.entries(input);
+  const result = csso.minify(code, {
+    filename,
+    sourceMap: Boolean(inputSourceMap),
+    ...minimizerOptions
+  });
+  return {
+    code: result.css,
+    map: result.map && result.map.toJSON()
+  };
+}
+/* istanbul ignore next */
+
+
+async function cleanCssMinify(input, inputSourceMap, minimizerOptions) {
+  // eslint-disable-next-line global-require,import/no-extraneous-dependencies
+  const CleanCSS = require("clean-css");
+
+  const [[name, code]] = Object.entries(input);
+  const result = await new CleanCSS({
+    sourceMap: Boolean(inputSourceMap),
+    ...minimizerOptions
+  }).minify({
+    [name]: {
+      styles: code
+    }
+  });
+  return {
+    code: result.styles,
+    map: result.sourceMap && result.sourceMap.toJSON(),
+    warnings: result.warnings
+  };
+}
+/* istanbul ignore next */
+
+
+async function esbuildMinify(input, sourceMap, minimizerOptions) {
+  const buildEsbuildOptions = (esbuildOptions = {}) => {
+    // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+    return {
+      loader: "css",
+      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 ? result.map : undefined,
+    warnings: result.warnings ? result.warnings.map(item => item.toString()) : []
+  };
+}