@umijs/bundler-esbuild 4.0.0-beta.9 → 4.0.0-canary-20240513.3

package/dist/plugins/externals.js

@@ -1,22 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (options) => {
-    return {
-        name: 'externals',
-        setup({ onLoad, onResolve }) {
-            if (!options || Object.keys(options).length === 0) {
-                return;
-            }
-            Object.keys(options).forEach((key) => {
-                onResolve({ filter: new RegExp(`^${key}$`) }, (args) => ({
-                    path: args.path,
-                    namespace: key,
-                }));
-                onLoad({ filter: /.*/, namespace: key }, () => ({
-                    contents: `module.export=${options[key]}`,
-                    loader: 'js',
-                }));
-            });
-        },
-    };
+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/externals.ts
+var externals_exports = {};
+__export(externals_exports, {
+  default: () => externals_default
+});
+module.exports = __toCommonJS(externals_exports);
+var externals_default = (options) => {
+  return {
+    name: "externals",
+    setup({ onLoad, onResolve }) {
+      if (!options || Object.keys(options).length === 0) {
+        return;
+      }
+      Object.keys(options).forEach((key) => {
+        onResolve({ filter: new RegExp(`^${key}$`) }, (args) => ({
+          path: args.path,
+          namespace: key
+        }));
+        onLoad({ filter: /.*/, namespace: key }, () => ({
+          contents: `module.export=${options[key]}`,
+          loader: "js"
+        }));
+      });
+    }
+  };
 };

package/dist/plugins/less-plugin-alias/index.d.ts

@@ -0,0 +1,9 @@
+interface Options {
+    alias: Record<string, string>;
+}
+export default class LessAliasPlugin {
+    private options;
+    constructor(options: Options);
+    install(less: LessStatic, pluginManager: Less.PluginManager): void;
+}
+export {};

package/dist/plugins/less-plugin-alias/index.js

@@ -0,0 +1,100 @@
+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/less-plugin-alias/index.ts
+var less_plugin_alias_exports = {};
+__export(less_plugin_alias_exports, {
+  default: () => LessAliasPlugin
+});
+module.exports = __toCommonJS(less_plugin_alias_exports);
+var import_utils = require("@umijs/utils");
+var import_utils2 = require("./utils");
+function matches(pattern, importee) {
+  if (pattern instanceof RegExp) {
+    return pattern.test(importee);
+  }
+  if (importee.length < pattern.length) {
+    return false;
+  }
+  if (importee === pattern) {
+    return true;
+  }
+  return importee.startsWith(pattern + "/");
+}
+var LessAliasPlugin = class {
+  constructor(options) {
+    this.options = options;
+  }
+  install(less, pluginManager) {
+    const alias = (0, import_utils2.parseAlias)(this.options.alias);
+    function resolveId(filename) {
+      if (!filename) {
+        return null;
+      }
+      const matchedEntry = alias.find((entry) => matches(entry.find, filename));
+      if (!matchedEntry) {
+        return filename;
+      }
+      const resolvedPath = filename.replace(
+        matchedEntry.find,
+        matchedEntry.replacement
+      );
+      return resolvedPath;
+    }
+    class AliasePlugin extends less.FileManager {
+      loadFile(filename, currentDirectory, options, enviroment) {
+        let resolved;
+        try {
+          resolved = resolveId(filename);
+        } catch (error) {
+          import_utils.logger.error(error);
+        }
+        if (!resolved) {
+          const error = new Error(
+            `[less-plugin-alias]: '${filename}' not found.`
+          );
+          import_utils.logger.error(error);
+          throw error;
+        }
+        return super.loadFile(resolved, currentDirectory, options, enviroment);
+      }
+      loadFileSync(filename, currentDirectory, options, enviroment) {
+        let resolved;
+        try {
+          resolved = resolveId(filename);
+        } catch (error) {
+          import_utils.logger.error(error);
+        }
+        if (!resolved) {
+          const error = new Error(
+            `[less-plugin-alias]: '${filename}' not found.`
+          );
+          import_utils.logger.error(error);
+          throw error;
+        }
+        return super.loadFileSync(
+          resolved,
+          currentDirectory,
+          options,
+          enviroment
+        );
+      }
+    }
+    pluginManager.addFileManager(new AliasePlugin());
+  }
+};

package/dist/plugins/less-plugin-alias/types.d.ts

@@ -0,0 +1,4 @@
+export interface Alias {
+    find: string | RegExp;
+    replacement: string;
+}

package/dist/plugins/less-plugin-alias/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/less-plugin-alias/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/plugins/less-plugin-alias/utils.d.ts

@@ -0,0 +1,2 @@
+import { Alias } from './types';
+export declare function parseAlias(alias: Record<string, string>): Alias[];

package/dist/plugins/less-plugin-alias/utils.js

@@ -0,0 +1,60 @@
+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/less-plugin-alias/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  parseAlias: () => parseAlias
+});
+module.exports = __toCommonJS(utils_exports);
+function hoistAlias(alias) {
+  function getFinalReplacement(oAlias, replacement, index) {
+    const newAlias = oAlias.slice();
+    newAlias.splice(index, 1);
+    for (let i = 0; i < newAlias.length; i++) {
+      if (newAlias[i].find.test(replacement)) {
+        replacement = replacement.replace(
+          newAlias[i].find,
+          newAlias[i].replacement
+        );
+        return getFinalReplacement(newAlias, replacement, i);
+      }
+    }
+    return replacement;
+  }
+  alias.forEach((rule, index, alias2) => {
+    rule.replacement = getFinalReplacement(alias2, rule.replacement, index);
+  });
+  return alias;
+}
+function parseAlias(alias) {
+  const wholeAlias = [
+    // to support less-loader ~ for local deps, refer: https://github.com/vitejs/vite/issues/2185
+    { find: /^~/, replacement: "" }
+  ];
+  const userAlias = Object.entries(alias).map(([name, target]) => ({
+    find: new RegExp(`^~?${name.replace(/(?<!\$)$/, "(?=/|$)")}`),
+    replacement: target
+  }));
+  wholeAlias.unshift(...userAlias);
+  return hoistAlias(wholeAlias);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseAlias
+});

package/dist/plugins/less.d.ts

@@ -1,4 +1,9 @@
-/// <reference types="less" />
 import { Plugin } from '@umijs/bundler-utils/compiled/esbuild';
-declare const _default: (options?: Less.Options) => Plugin;
+import { IConfig } from '../types';
+export declare const aliasLessImportPath: (filePath: string, alias: Record<string, string>, importer: string) => Promise<string | null>;
+declare const _default: (options?: Less.Options & {
+    alias?: Record<string, string>;
+    inlineStyle?: boolean;
+    config?: IConfig;
+}) => Plugin;
 export default _default;

package/dist/plugins/less.js

@@ -1,53 +1,207 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
-const less_1 = __importDefault(require("less"));
-const path_1 = __importDefault(require("path"));
-exports.default = (options = {}) => {
-    return {
-        name: 'less',
-        setup({ onLoad }) {
-            onLoad({ filter: /\.less$/, namespace: 'file' }, (args) => __awaiter(this, void 0, void 0, function* () {
-                const content = yield fs_1.promises.readFile(args.path, 'utf-8');
-                const dir = path_1.default.dirname(args.path);
-                const filename = path_1.default.basename(args.path);
-                try {
-                    const result = yield less_1.default.render(content, Object.assign(Object.assign({ filename, rootpath: dir }, options), { paths: [...(options.paths || []), dir] }));
-                    return {
-                        contents: result.css,
-                        loader: 'css',
-                        resolveDir: dir,
-                    };
-                }
-                catch (error) {
-                    return {
-                        errors: [
-                            {
-                                text: error.message,
-                                location: {
-                                    namespace: 'file',
-                                    file: error.filename,
-                                    line: error.line,
-                                    column: error.column,
-                                },
-                            },
-                        ],
-                        resolveDir: dir,
-                    };
+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/plugins/less.ts
+var less_exports = {};
+__export(less_exports, {
+  aliasLessImportPath: () => aliasLessImportPath,
+  default: () => less_default
+});
+module.exports = __toCommonJS(less_exports);
+var import_less = __toESM(require("@umijs/bundler-utils/compiled/less"));
+var import_enhanced_resolve = __toESM(require("enhanced-resolve"));
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+var import_postcssProcess = require("../utils/postcssProcess");
+var import_sortByAffix = require("../utils/sortByAffix");
+var import_less_plugin_alias = __toESM(require("./less-plugin-alias"));
+var resolver = import_enhanced_resolve.default.create({
+  mainFields: ["module", "browser", "main"],
+  extensions: [
+    ".json",
+    ".js",
+    ".jsx",
+    ".ts",
+    ".tsx",
+    ".cjs",
+    ".mjs",
+    ".less",
+    ".css"
+  ],
+  // TODO: support exports
+  exportsFields: []
+});
+async function resolve(context, path2) {
+  return new Promise((resolve2, reject) => {
+    resolver(
+      context,
+      path2,
+      (err, result) => err ? reject(err) : resolve2(result)
+    );
+  });
+}
+var aliasLessImports = async (ctx, alias, importer) => {
+  const importRegex = /@import(?:\s+\((.*)\))?\s+['"](.*)['"]/;
+  const globalImportRegex = /@import(?:\s+\((.*)\))?\s+['"](.*)['"]/g;
+  const match = ctx.match(globalImportRegex) || [];
+  for (const el of match) {
+    const [imp, _, filePath] = el.match(importRegex) || [];
+    let aliaPath = await aliasLessImportPath(filePath, alias, importer);
+    if (aliaPath) {
+      ctx = ctx.replace(imp, el.replace(filePath, aliaPath));
+    }
+  }
+  return ctx;
+};
+var aliasLessImportPath = async (filePath, alias, importer) => {
+  let aliaPath = filePath.startsWith("~") ? filePath.replace("~", "") : filePath;
+  const keys = (0, import_sortByAffix.sortByAffix)({ arr: Object.keys(alias), affix: "$" });
+  for (const key of keys) {
+    const pathSegments = aliaPath.split("/");
+    if (pathSegments[0] === key) {
+      pathSegments[0] = alias[key];
+      aliaPath = pathSegments.join("/");
+      aliaPath = import_path.default.extname(aliaPath) ? aliaPath : `${aliaPath}.less`;
+      return await resolve(importer, aliaPath);
+    }
+  }
+  return null;
+};
+var less_default = (options = {}) => {
+  const { alias, inlineStyle, config, ...lessOptions } = options;
+  return {
+    name: "less",
+    setup({ onResolve, onLoad }) {
+      onResolve({ filter: /\.less$/, namespace: "file" }, async (args) => {
+        let filePath = args.path;
+        let isMatchedAlias = false;
+        if (!!alias) {
+          const aliasMatchPath = await aliasLessImportPath(
+            filePath,
+            alias,
+            args.path
+          );
+          if (aliasMatchPath) {
+            isMatchedAlias = true;
+            filePath = aliasMatchPath;
+          }
+        }
+        if (!isMatchedAlias) {
+          const isImportFromDeps = !import_path.default.isAbsolute(filePath) && !filePath.startsWith(".");
+          if (isImportFromDeps) {
+            filePath = await resolve(process.cwd(), filePath);
+          } else {
+            filePath = import_path.default.resolve(
+              process.cwd(),
+              import_path.default.relative(process.cwd(), args.resolveDir),
+              args.path
+            );
+          }
+        }
+        return {
+          path: filePath,
+          namespace: inlineStyle ? "less-file" : "file"
+        };
+      });
+      if (inlineStyle) {
+        onResolve({ filter: /\.less$/, namespace: "less-file" }, (args) => {
+          return { path: args.path, namespace: "less-content" };
+        });
+        onResolve(
+          { filter: /^__style_helper__$/, namespace: "less-file" },
+          (args) => ({
+            path: args.path,
+            namespace: "style-helper",
+            sideEffects: false
+          })
+        );
+        onLoad({ filter: /.*/, namespace: "less-file" }, async (args) => ({
+          contents: `
+            import { injectStyle } from "__style_helper__"
+            import css from ${JSON.stringify(args.path)}
+            injectStyle(css)
+            export default{}
+          `
+        }));
+      }
+      onLoad(
+        { filter: /\.less$/, namespace: inlineStyle ? "less-content" : "file" },
+        async (args) => {
+          let content = await import_fs.promises.readFile(args.path, "utf-8");
+          if (!!alias) {
+            content = await aliasLessImports(content, alias, args.path);
+          }
+          const dir = import_path.default.dirname(args.path);
+          const filename = import_path.default.basename(args.path);
+          try {
+            const result = await import_less.default.render(content, {
+              plugins: [
+                new import_less_plugin_alias.default({
+                  alias: alias || {}
+                })
+              ],
+              filename,
+              rootpath: dir,
+              ...lessOptions,
+              paths: [...lessOptions.paths || [], dir]
+            });
+            const postcssrResult = await (0, import_postcssProcess.postcssProcess)(
+              config,
+              result.css,
+              args.path
+            );
+            return {
+              contents: postcssrResult.css,
+              loader: inlineStyle ? "text" : "css",
+              resolveDir: dir
+            };
+          } catch (error) {
+            return {
+              errors: [
+                {
+                  text: error.message,
+                  location: {
+                    namespace: "file",
+                    file: error.filename,
+                    line: error.line,
+                    column: error.column
+                  }
                 }
-            }));
-        },
-    };
+              ],
+              resolveDir: dir
+            };
+          }
+        }
+      );
+    }
+  };
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  aliasLessImportPath
+});

package/dist/plugins/nodeGlobalsPolyfill.js

@@ -1,14 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nodeGlobalsPolyfill = void 0;
+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/nodeGlobalsPolyfill.ts
+var nodeGlobalsPolyfill_exports = {};
+__export(nodeGlobalsPolyfill_exports, {
+  nodeGlobalsPolyfill: () => nodeGlobalsPolyfill
+});
+module.exports = __toCommonJS(nodeGlobalsPolyfill_exports);
 function nodeGlobalsPolyfill() {
-    return {
-        name: 'node-globals-polyfill',
-        setup({ initialOptions, onResolve, onLoad }) {
-            onResolve;
-            onLoad;
-            initialOptions.inject || (initialOptions.inject = []);
-        },
-    };
+  return {
+    name: "node-globals-polyfill",
+    setup({ initialOptions, onResolve, onLoad }) {
+      onResolve;
+      onLoad;
+      initialOptions.inject || (initialOptions.inject = []);
+    }
+  };
 }
-exports.nodeGlobalsPolyfill = nodeGlobalsPolyfill;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  nodeGlobalsPolyfill
+});

package/dist/plugins/style.d.ts

@@ -1,4 +1,5 @@
 import { Charset, Plugin } from '@umijs/bundler-utils/compiled/esbuild';
+import { IConfig } from '../types';
 export interface StylePluginOptions {
     /**
      * whether to minify the css code.
@@ -10,5 +11,7 @@ export interface StylePluginOptions {
      * @default 'utf8'
      */
     charset?: Charset;
+    inlineStyle?: boolean;
+    config?: IConfig;
 }
-export declare function inlineStyle({ minify, charset, }?: StylePluginOptions): Plugin;
+export declare function style({ minify, charset, inlineStyle, config, }?: StylePluginOptions): Plugin;