@umijs/bundler-esbuild 4.0.5 → 4.0.8

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

@@ -1,70 +1,90 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@umijs/utils");
-const utils_2 = require("./utils");
+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);
+
+// 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 + '/');
+  if (pattern instanceof RegExp) {
+    return pattern.test(importee);
+  }
+  if (importee.length < pattern.length) {
+    return false;
+  }
+  if (importee === pattern) {
+    return true;
+  }
+  return importee.startsWith(pattern + "/");
 }
-class LessAliasPlugin {
-    constructor(options) {
-        this.options = options;
+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;
     }
-    install(less, pluginManager) {
-        const alias = (0, utils_2.parseAlias)(this.options.alias);
-        function resolveId(filename) {
-            if (!filename) {
-                return null;
-            }
-            // First match is supposed to be the correct one
-            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);
         }
-        class AliasePlugin extends less.FileManager {
-            loadFile(filename, currentDirectory, options, enviroment) {
-                let resolved;
-                try {
-                    resolved = resolveId(filename);
-                }
-                catch (error) {
-                    utils_1.logger.error(error);
-                }
-                if (!resolved) {
-                    const error = new Error(`[less-plugin-alias]: '${filename}' not found.`);
-                    utils_1.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) {
-                    utils_1.logger.error(error);
-                }
-                if (!resolved) {
-                    const error = new Error(`[less-plugin-alias]: '${filename}' not found.`);
-                    utils_1.logger.error(error);
-                    throw error;
-                }
-                return super.loadFileSync(resolved, currentDirectory, options, enviroment);
-            }
+        if (!resolved) {
+          const error = new Error(`[less-plugin-alias]: '${filename}' not found.`);
+          import_utils.logger.error(error);
+          throw error;
         }
-        pluginManager.addFileManager(new AliasePlugin());
+        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);
+      }
     }
-}
-exports.default = LessAliasPlugin;
+    pluginManager.addFileManager(new AliasePlugin());
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

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

@@ -1,2 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+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);
+
+// types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -1,35 +1,56 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseAlias = 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);
+
+// 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;
+  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);
+      }
     }
-    alias.forEach((rule, index, alias) => {
-        rule.replacement = getFinalReplacement(alias, rule.replacement, index);
-    });
-    return alias;
+    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);
+  const wholeAlias = [
+    { find: /^~/, replacement: "" }
+  ];
+  const userAlias = Object.entries(alias).map(([name, target]) => ({
+    find: new RegExp(`^~?${name.replace(/(?<!\$)$/, "(?=/|$)")}`),
+    replacement: target
+  }));
+  wholeAlias.unshift(...userAlias);
+  return hoistAlias(wholeAlias);
 }
-exports.parseAlias = parseAlias;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseAlias
+});

package/dist/plugins/less.js

@@ -1,160 +1,206 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.aliasLessImportPath = void 0;
-const less_1 = __importDefault(require("@umijs/bundler-utils/compiled/less"));
-const enhanced_resolve_1 = __importDefault(require("enhanced-resolve"));
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const postcssProcess_1 = require("../utils/postcssProcess");
-const sortByAffix_1 = require("../utils/sortByAffix");
-const less_plugin_alias_1 = __importDefault(require("./less-plugin-alias"));
-const resolver = enhanced_resolve_1.default.create({
-    mainFields: ['module', 'browser', 'main'],
-    extensions: [
-        '.json',
-        '.js',
-        '.jsx',
-        '.ts',
-        '.tsx',
-        '.cjs',
-        '.mjs',
-        '.less',
-        '.css',
-    ],
-    // TODO: support exports
-    exportsFields: [],
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// less.ts
+var less_exports = {};
+__export(less_exports, {
+  aliasLessImportPath: () => aliasLessImportPath,
+  default: () => less_default
 });
-async function resolve(context, path) {
-    return new Promise((resolve, reject) => {
-        resolver(context, path, (err, result) => err ? reject(err) : resolve(result));
-    });
+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"
+  ],
+  exportsFields: []
+});
+async function resolve(context, path2) {
+  return new Promise((resolve2, reject) => {
+    resolver(context, path2, (err, result) => err ? reject(err) : resolve2(result));
+  });
 }
-const 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 (0, exports.aliasLessImportPath)(filePath, alias, importer);
-        if (aliaPath) {
-            ctx = ctx.replace(imp, el.replace(filePath, aliaPath));
-        }
+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;
+  }
+  return ctx;
 };
-const aliasLessImportPath = async (filePath, alias, importer) => {
-    // ～ 写法在 esbuild 中无实际意义
-    let aliaPath = filePath.startsWith('~')
-        ? filePath.replace('~', '')
-        : filePath;
-    const keys = (0, sortByAffix_1.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 = path_1.default.extname(aliaPath) ? aliaPath : `${aliaPath}.less`;
-            return await resolve(importer, aliaPath);
-        }
+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;
+  }
+  return null;
 };
-exports.aliasLessImportPath = aliasLessImportPath;
-exports.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;
-                // first match alias
-                if (!!alias) {
-                    const aliasMatchPath = await (0, exports.aliasLessImportPath)(filePath, alias, args.path);
-                    if (aliasMatchPath) {
-                        isMatchedAlias = true;
-                        filePath = aliasMatchPath;
-                    }
-                }
-                // if alias not matched, identify whether import from deps (node_modules)
-                if (!isMatchedAlias) {
-                    const isImportFromDeps = !path_1.default.isAbsolute(filePath) && !filePath.startsWith('.');
-                    if (isImportFromDeps) {
-                        filePath = await resolve(process.cwd(), filePath);
-                    }
-                    else {
-                        filePath = path_1.default.resolve(process.cwd(), path_1.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: `
+var less_default = (options = {}) => {
+  const _a = options, { alias, inlineStyle, config } = _a, lessOptions = __objRest(_a, ["alias", "inlineStyle", "config"]);
+  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 fs_1.promises.readFile(args.path, 'utf-8');
-                if (!!alias) {
-                    content = await aliasLessImports(content, alias, args.path);
-                }
-                const dir = path_1.default.dirname(args.path);
-                const filename = path_1.default.basename(args.path);
-                try {
-                    const result = await less_1.default.render(content, {
-                        plugins: [
-                            new less_plugin_alias_1.default({
-                                alias: alias || {},
-                            }),
-                        ],
-                        filename,
-                        rootpath: dir,
-                        ...lessOptions,
-                        paths: [...(lessOptions.paths || []), dir],
-                    });
-                    const postcssrResult = await (0, postcssProcess_1.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,
-                    };
+          `
+        }));
+      }
+      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, __spreadProps(__spreadValues({
+            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
+});