@modern-js/module-tools 2.35.1 → 2.37.0

package/dist/builder/esbuild/index.js

@@ -0,0 +1,268 @@
+"use strict";
+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);
+var esbuild_exports = {};
+__export(esbuild_exports, {
+  EsbuildCompiler: () => EsbuildCompiler,
+  createCompiler: () => createCompiler
+});
+module.exports = __toCommonJS(esbuild_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_esbuild = require("esbuild");
+var tapable = __toESM(require("tapable"));
+var import_utils = require("@modern-js/utils");
+var import_utils2 = require("../../utils");
+var import_feature = require("../feature");
+var import_build = require("../../constants/build");
+var import_adapter = require("./adapter");
+var import_transform = require("./transform");
+var import_sourcemap = require("./sourcemap");
+var import_hook = require("./hook");
+var import_resolve = require("./resolve");
+var import_watch = require("./watch");
+class EsbuildCompiler {
+  async init() {
+    if (this.context.watch) {
+      (0, import_watch.initWatcher)(this);
+    }
+    const internal = await (0, import_feature.getInternalList)(this.context);
+    const user = this.config.hooks;
+    this.hookList = [
+      ...user,
+      ...internal
+    ];
+    await Promise.all(this.hookList.map((item) => item.apply(this)));
+  }
+  addWatchFile(id) {
+    if (!this.watchedFiles.has(id)) {
+      var _this_watcher_add, _this_watcher;
+      (_this_watcher = this.watcher) === null || _this_watcher === void 0 ? void 0 : (_this_watcher_add = _this_watcher.add) === null || _this_watcher_add === void 0 ? void 0 : _this_watcher_add.call(_this_watcher, id);
+      this.watchedFiles.add(id);
+    }
+  }
+  convertConfigToEsbuild(config) {
+    const { input, buildType, define, target, sourceMap, platform, splitting, outDir, sourceDir, minify, jsx, esbuildOptions, format, asset, tsconfig, banner, footer } = config;
+    const bundle = buildType === "bundle";
+    const entryNames = bundle ? "[name]" : "[dir]/[name]";
+    const absWorkingDir = this.context.root;
+    let esbuildFormat = format === "umd" ? "esm" : format;
+    if (bundle && format === "cjs" && splitting) {
+      esbuildFormat = "esm";
+    }
+    const esbuildTarget = target === "es5" ? void 0 : target;
+    const jsExtensions = [
+      ".jsx",
+      ".tsx",
+      ".js",
+      ".ts",
+      ".json"
+    ];
+    const buildOptions = {
+      banner: import_utils.lodash.pick(banner, [
+        "js",
+        "css"
+      ]),
+      footer: import_utils.lodash.pick(footer, [
+        "js",
+        "css"
+      ]),
+      entryPoints: input,
+      metafile: true,
+      define,
+      bundle: buildType === "bundle",
+      format: esbuildFormat,
+      target: esbuildTarget,
+      sourcemap: sourceMap ? "external" : false,
+      resolveExtensions: jsExtensions,
+      splitting,
+      charset: "utf8",
+      logLimit: 5,
+      absWorkingDir,
+      platform,
+      tsconfig: import_utils.fs.existsSync(tsconfig) ? tsconfig : void 0,
+      write: false,
+      logLevel: "silent",
+      outdir: outDir,
+      outbase: sourceDir,
+      entryNames,
+      plugins: [
+        (0, import_adapter.adapterPlugin)(this)
+      ],
+      minify: minify === "esbuild",
+      jsx,
+      supported: {
+        "dynamic-import": buildType === "bundle" || format !== "cjs"
+      },
+      assetNames: `${asset.path}/[name].[hash]`
+    };
+    return esbuildOptions(buildOptions);
+  }
+  getTransformContext(path) {
+    if (this.transformContextMap.has(path)) {
+      return this.transformContextMap.get(path);
+    }
+    const context2 = new import_transform.TransformContext(Boolean(this.context.config.sourceMap));
+    this.transformContextMap.set(path, context2);
+    return context2;
+  }
+  getSourcemapContext(path) {
+    if (this.sourcemapContextMap.has(path)) {
+      return this.sourcemapContextMap.get(path);
+    }
+    const context2 = new import_sourcemap.SourcemapContext(Boolean(this.context.config.sourceMap));
+    this.sourcemapContextMap.set(path, context2);
+    return context2;
+  }
+  emitAsset(name, chunk) {
+    if (typeof chunk === "string") {
+      this.outputChunk.set(name, {
+        type: "asset",
+        contents: chunk,
+        fileName: name
+      });
+    } else {
+      this.outputChunk.set(name, chunk);
+    }
+  }
+  async close() {
+    try {
+      var _this_instance, _this_instance1;
+      await ((_this_instance = this.instance) === null || _this_instance === void 0 ? void 0 : _this_instance.cancel());
+      await ((_this_instance1 = this.instance) === null || _this_instance1 === void 0 ? void 0 : _this_instance1.dispose());
+    } catch (err) {
+    }
+  }
+  async build() {
+    const { buildOptions, context: { watch } } = this;
+    try {
+      if (watch) {
+        this.instance = await (0, import_esbuild.context)(buildOptions);
+        this.result = await this.instance.rebuild();
+      } else {
+        this.result = await (0, import_esbuild.build)(buildOptions);
+      }
+      if (this.result.warnings.length) {
+        const warnings = this.result.warnings.filter((warning) => {
+          if (warning.text.includes(`This call to "require" will not be bundled because`) || warning.text.includes(`Indirect calls to "require" will not be bundled`) || warning.text.includes(`Converting "require" to "esm" is currently not supported`)) {
+            return false;
+          }
+          return true;
+        });
+        const messages = await (0, import_esbuild.formatMessages)(warnings, {
+          kind: "warning"
+        });
+        messages.forEach((m) => {
+          import_utils.logger.warn(m);
+        });
+      }
+    } catch (error) {
+      if (watch) {
+        var _this_instance;
+        (_this_instance = this.instance) === null || _this_instance === void 0 ? void 0 : _this_instance.cancel();
+        import_utils.logger.error(error);
+      } else {
+        throw error;
+      }
+    }
+  }
+  async reBuild(type, config) {
+    const { instance } = this;
+    try {
+      const start = Date.now();
+      if (type === "link") {
+        await this.build();
+      } else {
+        this.result = await (instance === null || instance === void 0 ? void 0 : instance.rebuild());
+      }
+      const time = import_utils.chalk.gray(`(${Date.now() - start}ms)`);
+      import_utils.logger.success((0, import_utils2.withLogTitle)(config.buildType, `Build ${config.format},${config.target} files ${time}`));
+    } catch (error) {
+      import_utils.logger.error(error);
+    }
+  }
+  constructor(context2) {
+    (0, import_define_property._)(this, "instance", void 0);
+    (0, import_define_property._)(this, "result", void 0);
+    (0, import_define_property._)(this, "hookList", void 0);
+    (0, import_define_property._)(this, "reBuildCount", void 0);
+    (0, import_define_property._)(this, "buildOptions", void 0);
+    (0, import_define_property._)(this, "context", void 0);
+    (0, import_define_property._)(this, "config", void 0);
+    (0, import_define_property._)(this, "hooks", void 0);
+    (0, import_define_property._)(this, "api", void 0);
+    (0, import_define_property._)(this, "outputChunk", /* @__PURE__ */ new Map());
+    (0, import_define_property._)(this, "watchedFiles", /* @__PURE__ */ new Set());
+    (0, import_define_property._)(this, "css_resolve", void 0);
+    (0, import_define_property._)(this, "node_resolve", void 0);
+    (0, import_define_property._)(this, "watcher", void 0);
+    (0, import_define_property._)(this, "virtualModule", /* @__PURE__ */ new Map());
+    (0, import_define_property._)(this, "transformContextMap", /* @__PURE__ */ new Map());
+    (0, import_define_property._)(this, "sourcemapContextMap", /* @__PURE__ */ new Map());
+    const { api, config, root } = context2;
+    this.reBuildCount = 0;
+    this.context = context2;
+    this.api = api;
+    this.config = config;
+    this.buildOptions = this.convertConfigToEsbuild(config);
+    this.hooks = Object.freeze({
+      load: new tapable.AsyncSeriesBailHook([
+        "loadArgs"
+      ]),
+      transform: (0, import_hook.createTransformHook)(this),
+      renderChunk: (0, import_hook.createRenderChunkHook)(this)
+    });
+    const resolveOptions = {
+      root,
+      platform: config.platform,
+      alias: config.alias,
+      tsconfig: config.tsconfig,
+      mainFields: config.resolve.mainFields
+    };
+    this.css_resolve = (0, import_resolve.createCssResolver)({
+      ...resolveOptions,
+      resolveType: "css",
+      extensions: import_build.cssExtensions,
+      preferRelative: true
+    });
+    this.node_resolve = (0, import_resolve.createJsResolver)({
+      ...resolveOptions,
+      resolveType: "js",
+      extensions: config.resolve.jsExtensions
+    });
+  }
+}
+const createCompiler = async (context2) => {
+  const compiler = new EsbuildCompiler(context2);
+  await compiler.init();
+  return compiler;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EsbuildCompiler,
+  createCompiler
+});

package/dist/builder/esbuild/resolve.d.ts

@@ -0,0 +1,18 @@
+import { ImportKind, Platform } from 'esbuild';
+/**
+ * supports require js plugin in less file
+ */
+export declare const cssExtensions: string[];
+export declare const createJsResolver: (options: ResolverOptions) => (id: string, dir: string, kind?: ImportKind) => string | false;
+export declare const createCssResolver: (options: ResolverOptions) => (id: string, dir: string, kind?: ImportKind) => string;
+interface ResolverOptions {
+  platform: Platform;
+  resolveType: 'js' | 'css';
+  extensions: string[];
+  root: string;
+  alias: Record<string, string>;
+  tsconfig: string;
+  mainFields: string[];
+  preferRelative?: boolean;
+}
+export {};

package/dist/builder/esbuild/resolve.js

@@ -0,0 +1,140 @@
+"use strict";
+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);
+var resolve_exports = {};
+__export(resolve_exports, {
+  createCssResolver: () => createCssResolver,
+  createJsResolver: () => createJsResolver,
+  cssExtensions: () => cssExtensions
+});
+module.exports = __toCommonJS(resolve_exports);
+var import_fs = __toESM(require("fs"));
+var import_enhanced_resolve = require("enhanced-resolve");
+var import_tsconfig_paths_webpack_plugin = __toESM(require("tsconfig-paths-webpack-plugin"));
+const cssExtensions = [
+  ".less",
+  ".css",
+  ".sass",
+  ".scss",
+  ".js"
+];
+function createEnhancedResolve(options) {
+  const plugins = [];
+  const { tsconfig } = options;
+  if (import_fs.default.existsSync(tsconfig)) {
+    plugins.push(new import_tsconfig_paths_webpack_plugin.default({
+      configFile: tsconfig
+    }));
+  }
+  const resolveOptions = {
+    aliasFields: options.platform === "browser" ? [
+      "browser"
+    ] : [],
+    FileSystem: new import_enhanced_resolve.CachedInputFileSystem(import_fs.default, 4e3),
+    mainFields: options.mainFields,
+    mainFiles: [
+      "index"
+    ],
+    extensions: options.extensions,
+    preferRelative: options.preferRelative,
+    addMatchAll: false,
+    plugins,
+    alias: options.alias
+  };
+  const resolveSync = (dir, id) => import_enhanced_resolve.create.sync({
+    ...resolveOptions,
+    conditionNames: [
+      options.platform,
+      "require",
+      "module"
+    ]
+  })(dir, id);
+  const esmResolveSync = (dir, id) => import_enhanced_resolve.create.sync({
+    ...resolveOptions,
+    conditionNames: [
+      options.platform,
+      "import",
+      "module"
+    ]
+  })(dir, id);
+  return {
+    resolveSync,
+    esmResolveSync
+  };
+}
+const createJsResolver = (options) => {
+  const resolveCache = /* @__PURE__ */ new Map();
+  const { resolveSync, esmResolveSync } = createEnhancedResolve(options);
+  const resolver = (id, dir, kind) => {
+    const cacheKey = id + dir + (kind || "");
+    const cacheResult = resolveCache.get(cacheKey);
+    if (cacheResult) {
+      return cacheResult;
+    }
+    let result;
+    if (kind === "import-statement" || kind === "dynamic-import") {
+      result = esmResolveSync(dir, id);
+    } else {
+      result = resolveSync(dir, id);
+    }
+    if (result) {
+      resolveCache.set(cacheKey, result);
+    }
+    return result;
+  };
+  return resolver;
+};
+const createCssResolver = (options) => {
+  const resolveCache = /* @__PURE__ */ new Map();
+  const { resolveSync } = createEnhancedResolve(options);
+  const resolver = (id, dir, kind) => {
+    const cacheKey = id + dir + (kind || "");
+    const cacheResult = resolveCache.get(cacheKey);
+    if (cacheResult) {
+      return cacheResult;
+    }
+    let result;
+    try {
+      result = resolveSync(dir, id);
+    } catch (err) {
+      result = resolveSync(dir, id.replace(/^~/, ""));
+    }
+    if (!result) {
+      throw new Error(`can not resolve ${id} from ${dir}`);
+    }
+    resolveCache.set(cacheKey, result);
+    return result;
+  };
+  return resolver;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCssResolver,
+  createJsResolver,
+  cssExtensions
+});

package/dist/builder/esbuild/sourcemap.d.ts

@@ -0,0 +1,16 @@
+import { SourceMap, ISourcemapContext } from '../../types';
+export declare class SourcemapContext implements ISourcemapContext {
+  private enableSourceMap?;
+  private sourceMapChain;
+  private sourceMapDirty;
+  private cachedInlineSourceMap;
+  private cachedSourceMap;
+  private pluginIdMap;
+  constructor(enableSourceMap?: boolean | undefined);
+  private markSourceMapStatus;
+  addSourceMap(pluginId: number, map?: SourceMap): void;
+  getInlineSourceMap(): string;
+  getSourceMap(): SourceMap | undefined;
+  getSourceMapChain(): SourceMap[];
+  genPluginId(name: string): number;
+}

package/dist/builder/esbuild/sourcemap.js

@@ -0,0 +1,86 @@
+"use strict";
+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);
+var sourcemap_exports = {};
+__export(sourcemap_exports, {
+  SourcemapContext: () => SourcemapContext
+});
+module.exports = __toCommonJS(sourcemap_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_utils = require("../../utils");
+class SourcemapContext {
+  markSourceMapStatus(dirty) {
+    this.sourceMapDirty = dirty;
+  }
+  addSourceMap(pluginId, map) {
+    if (this.enableSourceMap && this.sourceMapChain[pluginId] !== map) {
+      this.sourceMapChain[pluginId] = map;
+      this.markSourceMapStatus(true);
+    }
+  }
+  getInlineSourceMap() {
+    if (this.sourceMapDirty && this.enableSourceMap) {
+      const effectMapList = this.getSourceMapChain().reverse();
+      if (effectMapList.length > 0) {
+        this.cachedInlineSourceMap = (0, import_utils.mergeMaps)(effectMapList).toComment();
+      } else {
+        this.cachedInlineSourceMap = "";
+      }
+      this.markSourceMapStatus(false);
+    }
+    return this.cachedInlineSourceMap;
+  }
+  getSourceMap() {
+    if (this.sourceMapDirty && this.enableSourceMap) {
+      const effectMapList = this.getSourceMapChain().reverse();
+      if (effectMapList.length > 0) {
+        this.cachedSourceMap = (0, import_utils.mergeMaps)(effectMapList).toMap();
+      }
+      this.markSourceMapStatus(false);
+    }
+    return this.cachedSourceMap;
+  }
+  getSourceMapChain() {
+    return this.sourceMapChain.filter((m) => Boolean(m && m.mappings));
+  }
+  genPluginId(name) {
+    if (this.pluginIdMap.has(name)) {
+      return this.pluginIdMap.get(name);
+    }
+    const id = this.sourceMapChain.length;
+    this.pluginIdMap.set(name, id);
+    return id;
+  }
+  constructor(enableSourceMap) {
+    (0, import_define_property._)(this, "enableSourceMap", void 0);
+    (0, import_define_property._)(this, "sourceMapChain", void 0);
+    (0, import_define_property._)(this, "sourceMapDirty", void 0);
+    (0, import_define_property._)(this, "cachedInlineSourceMap", void 0);
+    (0, import_define_property._)(this, "cachedSourceMap", void 0);
+    (0, import_define_property._)(this, "pluginIdMap", void 0);
+    this.enableSourceMap = enableSourceMap;
+    this.sourceMapChain = [];
+    this.sourceMapDirty = false;
+    this.cachedInlineSourceMap = "";
+    this.pluginIdMap = /* @__PURE__ */ new Map();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SourcemapContext
+});

package/dist/builder/esbuild/transform.d.ts

@@ -0,0 +1,7 @@
+import { ITransformContext, CacheValue } from '../../types';
+import { SourcemapContext } from './sourcemap';
+export declare class TransformContext extends SourcemapContext implements ITransformContext {
+  private cachedTransformResult;
+  addTransformResult(pluginId: number, result: CacheValue): void;
+  getValidCache(pluginId: number, code: string): CacheValue | undefined;
+}

package/dist/builder/esbuild/transform.js

@@ -0,0 +1,45 @@
+"use strict";
+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);
+var transform_exports = {};
+__export(transform_exports, {
+  TransformContext: () => TransformContext
+});
+module.exports = __toCommonJS(transform_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_sourcemap = require("./sourcemap");
+class TransformContext extends import_sourcemap.SourcemapContext {
+  addTransformResult(pluginId, result) {
+    this.cachedTransformResult.set(pluginId, result);
+    this.addSourceMap(pluginId, result.map);
+  }
+  getValidCache(pluginId, code) {
+    const cache = this.cachedTransformResult.get(pluginId);
+    if (cache && cache.originCode === code) {
+      return cache;
+    }
+  }
+  constructor(...args) {
+    super(...args);
+    (0, import_define_property._)(this, "cachedTransformResult", /* @__PURE__ */ new Map());
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransformContext
+});

package/dist/builder/esbuild/watch.d.ts

@@ -0,0 +1,2 @@
+import { ICompiler } from '../../types';
+export declare const initWatcher: (compiler: ICompiler) => void;