@umijs/bundler-webpack 4.2.6-alpha.6 → 4.2.6

package/dist/loader/swc.js

@@ -0,0 +1,149 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/loader/swc.ts
+var swc_exports = {};
+__export(swc_exports, {
+  default: () => swc_default
+});
+module.exports = __toCommonJS(swc_exports);
+var import_core = require("@swc/core");
+var import_types = require("../types");
+var import_utils = require("@umijs/utils");
+function getBaseOpts({ filename }) {
+  const isTSFile = filename.endsWith(".ts");
+  const isTypeScript = isTSFile || filename.endsWith(".tsx");
+  const isDev = process.env.NODE_ENV === import_types.Env.development;
+  const swcOpts = {
+    module: {
+      // @ts-ignore
+      type: "es6",
+      ignoreDynamic: true
+    },
+    jsc: {
+      parser: {
+        syntax: isTypeScript ? "typescript" : "ecmascript",
+        [isTypeScript ? "tsx" : "jsx"]: !isTSFile,
+        dynamicImport: isTypeScript
+      },
+      target: "es2015",
+      transform: {
+        react: {
+          runtime: "automatic",
+          pragma: "React.createElement",
+          pragmaFrag: "React.Fragment",
+          throwIfNamespace: true,
+          development: isDev,
+          useBuiltins: true
+        }
+      }
+    }
+  };
+  return swcOpts;
+}
+function swcLoader(contents, inputSourceMap) {
+  const callback = this.async();
+  const loaderOpts = this.getOptions();
+  if (inputSourceMap && typeof inputSourceMap === "object") {
+    inputSourceMap = JSON.stringify(inputSourceMap);
+  }
+  const {
+    sync = false,
+    parseMap = false,
+    excludeFiles = [],
+    enableAutoCssModulesPlugin = false,
+    mergeConfigs,
+    ...otherOpts
+  } = loaderOpts;
+  const filename = this.resourcePath;
+  const isSkip = excludeFiles.some((pattern) => {
+    if (typeof pattern === "string") {
+      return filename == pattern;
+    }
+    return pattern.test(filename);
+  });
+  if (isSkip) {
+    return callback(
+      null,
+      contents,
+      parseMap ? JSON.parse(inputSourceMap) : inputSourceMap
+    );
+  }
+  let swcOpts = {
+    ...getBaseOpts({
+      filename
+    }),
+    // filename
+    filename,
+    sourceFileName: filename,
+    // source map
+    sourceMaps: this.sourceMap,
+    ...inputSourceMap ? {
+      inputSourceMap
+    } : {},
+    ...otherOpts
+  };
+  if (enableAutoCssModulesPlugin) {
+    swcOpts = (0, import_utils.deepmerge)(swcOpts, {
+      jsc: {
+        experimental: {
+          plugins: [[require.resolve("swc-plugin-auto-css-modules"), {}]]
+        }
+      }
+    });
+  }
+  if (mergeConfigs) {
+    swcOpts = (0, import_utils.deepmerge)(swcOpts, mergeConfigs);
+  }
+  try {
+    if (sync) {
+      const output = (0, import_core.transformSync)(contents, swcOpts);
+      callback(
+        null,
+        output.code,
+        parseMap ? JSON.parse(output.map) : output.map
+      );
+    } else {
+      (0, import_core.transform)(contents, swcOpts).then(
+        (output) => {
+          callback(
+            null,
+            output.code,
+            parseMap ? JSON.parse(output.map) : output.map
+          );
+        },
+        (err) => {
+          callback(err);
+        }
+      );
+    }
+  } catch (e) {
+    callback(e);
+  }
+}
+var swc_default = swcLoader;

package/dist/parcelCSS.d.ts

@@ -0,0 +1,2 @@
+import * as parcelCSS from 'lightningcss';
+export { parcelCSS };

package/dist/parcelCSS.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/parcelCSS.ts
+var parcelCSS_exports = {};
+__export(parcelCSS_exports, {
+  parcelCSS: () => parcelCSS
+});
+module.exports = __toCommonJS(parcelCSS_exports);
+var parcelCSS = __toESM(require("lightningcss"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parcelCSS
+});

package/dist/plugins/EsbuildMinifyFix.d.ts

@@ -0,0 +1,8 @@
+import { Compilation, Compiler, sources } from '../../compiled/webpack';
+export declare class EsbuildMinifyFix {
+    private name;
+    constructor();
+    apply(compiler: Compiler): void;
+    private isIIFE;
+    minifyFix(compilation: Compilation, assets: Record<string, sources.Source>): Promise<void>;
+}

package/dist/plugins/EsbuildMinifyFix.js

@@ -0,0 +1,136 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/EsbuildMinifyFix.ts
+var EsbuildMinifyFix_exports = {};
+__export(EsbuildMinifyFix_exports, {
+  EsbuildMinifyFix: () => EsbuildMinifyFix
+});
+module.exports = __toCommonJS(EsbuildMinifyFix_exports);
+var import_utils = require("@umijs/utils");
+var import_webpack = require("../../compiled/webpack");
+var JS_FILE_REG = /\.(js|mjs|cjs)$/;
+var EsbuildMinifyFix = class {
+  constructor() {
+    this.name = `EsbuildMinifyFix`;
+  }
+  apply(compiler) {
+    compiler.hooks.compilation.tap(this.name, (compilation) => {
+      compilation.hooks.processAssets.tapPromise(
+        {
+          name: this.name,
+          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING,
+          additionalAssets: true
+        },
+        (assets) => this.minifyFix(compilation, assets)
+      );
+    });
+  }
+  isIIFE(source) {
+    source = source.trim();
+    if (source.startsWith('(function(){"use strict";')) {
+      return true;
+    }
+    if (source.startsWith("(function(){") && (source.endsWith("})()") || source.endsWith("})();"))) {
+      return true;
+    }
+    return false;
+  }
+  async minifyFix(compilation, assets) {
+    const matchObject = import_webpack.ModuleFilenameHelpers.matchObject.bind(void 0, {
+      include: [JS_FILE_REG]
+    });
+    const assetsForMinify = await Promise.all(
+      Object.keys(assets).filter((name) => {
+        var _a;
+        if (!matchObject(name)) {
+          return false;
+        }
+        const { info } = compilation.getAsset(name) || {};
+        if (!(info == null ? void 0 : info.minimized)) {
+          return false;
+        }
+        if (info == null ? void 0 : info.copied) {
+          return false;
+        }
+        if (info == null ? void 0 : info.EsbuildMinifyFix) {
+          return false;
+        }
+        if (name.endsWith(".worker.js")) {
+          return false;
+        }
+        if ((_a = info == null ? void 0 : info.related) == null ? void 0 : _a.sourceMap) {
+          return false;
+        }
+        return true;
+      }).map(async (name) => {
+        const { info, source } = compilation.getAsset(name);
+        return { name, info, inputSource: source };
+      })
+    );
+    if (assetsForMinify.length === 0) {
+      return;
+    }
+    const { SourceMapSource, RawSource } = import_webpack.sources;
+    for (const asset of assetsForMinify) {
+      const { name, inputSource } = asset;
+      const { source, map } = inputSource.sourceAndMap();
+      const originCode = source.toString();
+      let newCode = originCode;
+      if (!newCode.startsWith('"use strict";(self.') && !newCode.startsWith("(self.webpack") && !this.isIIFE(newCode)) {
+        const bundle = new import_utils.MagicString(newCode);
+        bundle.prepend("!(function(){").append("}());");
+        newCode = bundle.toString();
+        const output = {};
+        if (map) {
+          const bundleMap = bundle.generateMap({
+            source: name,
+            file: `${name}.map`,
+            includeContent: true,
+            hires: true
+          });
+          const originMapAsString = JSON.stringify(map);
+          const mergedMap = (0, import_utils.remapping)(JSON.stringify(bundleMap), (file) => {
+            if (file === name) {
+              return originMapAsString;
+            }
+            return null;
+          });
+          output.source = new SourceMapSource(
+            newCode,
+            name,
+            mergedMap,
+            originCode,
+            map,
+            true
+          );
+        } else {
+          output.source = new RawSource(newCode);
+        }
+        compilation.updateAsset(name, output.source, {
+          ...asset.info,
+          EsbuildMinifyFix: true
+        });
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EsbuildMinifyFix
+});

package/dist/plugins/ProgressPlugin.d.ts

@@ -0,0 +1,15 @@
+import { Compiler, ProgressPlugin } from '@umijs/bundler-webpack/compiled/webpack';
+interface IOpts {
+    name?: string;
+}
+declare class UmiProgressPlugin extends ProgressPlugin {
+    options: IOpts;
+    constructor(options?: IOpts);
+    apply(compiler: Compiler): void;
+    updateProgress(opts: {
+        percent: number;
+        message: string;
+        details: any[];
+    }): void;
+}
+export default UmiProgressPlugin;

package/dist/plugins/ProgressPlugin.js

@@ -0,0 +1,69 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/ProgressPlugin.ts
+var ProgressPlugin_exports = {};
+__export(ProgressPlugin_exports, {
+  default: () => ProgressPlugin_default
+});
+module.exports = __toCommonJS(ProgressPlugin_exports);
+var import_webpack = require("@umijs/bundler-webpack/compiled/webpack");
+var import_utils = require("@umijs/utils");
+var PLUGIN_NAME = "ProgressPlugin";
+var UmiProgressPlugin = class extends import_webpack.ProgressPlugin {
+  constructor(options = {}) {
+    super({ activeModules: true });
+    this.options = options;
+    this.handler = (percent, message, ...details) => {
+      this.updateProgress({ percent, message, details });
+    };
+  }
+  apply(compiler) {
+    const prefix = this.options.name ? `[${this.options.name}]` : "[Webpack]";
+    compiler.hooks.invalid.tap(PLUGIN_NAME, () => {
+      import_utils.logger.wait(`${prefix} Compiling...`);
+    });
+    compiler.hooks.done.tap(PLUGIN_NAME, (stats) => {
+      const { errors, warnings } = stats.toJson({
+        all: false,
+        warnings: true,
+        errors: true,
+        colors: true
+      });
+      const hasErrors = !!(errors == null ? void 0 : errors.length);
+      const hasWarnings = !!(warnings == null ? void 0 : warnings.length);
+      hasWarnings;
+      if (hasErrors) {
+        errors.forEach((error) => {
+          import_utils.logger.error(
+            `${error.moduleName}${error.loc ? `:${error.loc}` : ""}`
+          );
+          console.log(error.message);
+        });
+      } else {
+        import_utils.logger.event(
+          `${prefix} Compiled in ${stats.endTime - stats.startTime} ms (${stats.compilation.modules.size} modules)`
+        );
+      }
+    });
+  }
+  updateProgress(opts) {
+    opts;
+  }
+};
+var ProgressPlugin_default = UmiProgressPlugin;

package/dist/plugins/RuntimePublicPathPlugin.d.ts

@@ -0,0 +1,4 @@
+import type { Compiler } from '@umijs/bundler-webpack/compiled/webpack';
+export declare class RuntimePublicPathPlugin {
+    apply(compiler: Compiler): void;
+}

package/dist/plugins/RuntimePublicPathPlugin.js

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/RuntimePublicPathPlugin.ts
+var RuntimePublicPathPlugin_exports = {};
+__export(RuntimePublicPathPlugin_exports, {
+  RuntimePublicPathPlugin: () => RuntimePublicPathPlugin
+});
+module.exports = __toCommonJS(RuntimePublicPathPlugin_exports);
+var PLUGIN_NAME = "RuntimePublicPath";
+var RuntimePublicPathPlugin = class {
+  apply(compiler) {
+    compiler.hooks.make.tap(PLUGIN_NAME, (compilation) => {
+      compilation.hooks.runtimeModule.tap(
+        PLUGIN_NAME,
+        (module2) => {
+          if (module2.constructor.name === "PublicPathRuntimeModule") {
+            if (module2.getGeneratedCode().includes("webpack:///mini-css-extract-plugin"))
+              return;
+            module2._cachedGeneratedCode = `__webpack_require__.p = (typeof globalThis !== 'undefined' ? globalThis : window).publicPath || '/';`;
+          }
+        }
+      );
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimePublicPathPlugin
+});

package/dist/plugins/_SamplePlugin.d.ts

@@ -0,0 +1,9 @@
+import type { Compiler } from '@umijs/bundler-webpack/compiled/webpack';
+interface IOpts {
+}
+declare class _SamplePlugin {
+    options: IOpts;
+    constructor(options?: IOpts);
+    apply(compiler: Compiler): void;
+}
+export default _SamplePlugin;

package/dist/plugins/_SamplePlugin.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/_SamplePlugin.ts
+var SamplePlugin_exports = {};
+__export(SamplePlugin_exports, {
+  default: () => SamplePlugin_default
+});
+module.exports = __toCommonJS(SamplePlugin_exports);
+var PLUGIN_NAME = "SamplePlugin";
+var _SamplePlugin = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  apply(compiler) {
+    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+      compilation.hooks.chunkHash.tap(PLUGIN_NAME, () => {
+      });
+    });
+  }
+};
+var SamplePlugin_default = _SamplePlugin;

package/dist/requireHook.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/requireHook.js

@@ -0,0 +1,49 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
+  mod2
+));
+
+// src/requireHook.ts
+var import_deepImports = __toESM(require("@umijs/bundler-webpack/compiled/webpack/deepImports.json"));
+var import_path = require("path");
+var PKG_ROOT = (0, import_path.join)(__dirname, "../");
+var resolve = (p) => (0, import_path.join)(PKG_ROOT, p);
+var hookPropertyMap = /* @__PURE__ */ new Map([
+  ["webpack", resolve("compiled/webpack")],
+  ["webpack/package", resolve("compiled/webpack/package")],
+  ["webpack/package.json", resolve("compiled/webpack/package")],
+  ["webpack/lib/webpack", resolve("compiled/webpack")],
+  ["webpack/lib/webpack.js", resolve("compiled/webpack")],
+  ["tapable", require.resolve("@umijs/bundler-utils/compiled/tapable")]
+]);
+import_deepImports.default.forEach((item) => {
+  const name = item.split("/").pop();
+  hookPropertyMap.set(item, resolve(`compiled/webpack/${name}`));
+  hookPropertyMap.set(`${item}.js`, resolve(`compiled/webpack/${name}`));
+});
+var mod = require("module");
+var resolveFilename = mod._resolveFilename;
+mod._resolveFilename = function(request, parent, isMain, options) {
+  const hookResolved = hookPropertyMap.get(request);
+  if (hookResolved)
+    request = hookResolved;
+  return resolveFilename.call(mod, request, parent, isMain, options);
+};

package/dist/schema.d.ts

@@ -0,0 +1,4 @@
+import type { z } from '@umijs/utils/compiled/zod';
+export declare function getSchemas(): Record<string, (arg: {
+    zod: typeof z;
+}) => any>;