@modern-js/module-tools 2.35.1 → 2.37.0

package/dist/builder/esbuild/watch.js

@@ -0,0 +1,115 @@
+"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 watch_exports = {};
+__export(watch_exports, {
+  initWatcher: () => initWatcher
+});
+module.exports = __toCommonJS(watch_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+const initWatcher = (compiler) => {
+  const { config, api } = compiler;
+  const watch = import_utils.chokidar.watch([
+    compiler.context.root
+  ], {
+    useFsEvents: false,
+    ignored: [
+      "**/node_modules",
+      "**/.gitignore",
+      "**/.git",
+      compiler.config.outDir
+    ],
+    cwd: compiler.context.root
+  });
+  compiler.watcher = watch;
+  let running = false;
+  let needReRun = false;
+  const handleLink = async (filePath, type) => {
+    const { config: config2, context: { root } } = compiler;
+    const { buildType, input, sourceDir } = config2;
+    const absFilePath = import_path.default.resolve(root, filePath);
+    let shouldRebuild = false;
+    if (buildType === "bundleless" && Array.isArray(input)) {
+      if (type === "add") {
+        shouldRebuild = absFilePath.startsWith(sourceDir);
+      } else {
+        shouldRebuild = input.some((item) => item === filePath);
+      }
+    }
+    if (shouldRebuild) {
+      const text = type === "add" ? "added" : "unlinked";
+      import_utils.logger.info(`${import_utils.chalk.underline(filePath)} ${text}`);
+      if (type === "unlink") {
+        input.splice(input.indexOf(filePath), 1);
+      } else {
+        input.push(filePath);
+      }
+      if (running) {
+        needReRun = true;
+      } else {
+        running = true;
+        await compiler.reBuild("link", config2);
+        running = false;
+        if (needReRun) {
+          needReRun = false;
+          await compiler.reBuild("link", config2);
+        }
+      }
+    }
+  };
+  const handleAdd = async (filePath) => {
+    return handleLink(filePath, "add");
+  };
+  const handleUnlink = async (filePath) => {
+    return handleLink(filePath, "unlink");
+  };
+  const handleChange = async (filePath, _events) => {
+    const { context: { root }, watchedFiles } = compiler;
+    if (watchedFiles.has(import_path.default.resolve(root, filePath))) {
+      import_utils.logger.info(`File changed: ${import_utils.chalk.dim(filePath)}`);
+      const runner = api.useHookRunners();
+      runner.buildWatchJs({
+        buildConfig: config
+      });
+      await compiler.reBuild("change", config);
+    }
+  };
+  watch.on("ready", () => {
+    watch.on("change", handleChange);
+    watch.on("add", handleAdd);
+    watch.on("unlink", handleUnlink);
+  });
+  watch.once("restart", () => {
+    watch.removeListener("change", handleChange);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initWatcher
+});

package/dist/builder/esbuild/write-file.d.ts

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

package/dist/builder/esbuild/write-file.js

@@ -0,0 +1,89 @@
+"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 write_file_exports = {};
+__export(write_file_exports, {
+  writeFile: () => writeFile
+});
+module.exports = __toCommonJS(write_file_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_convert_source_map = __toESM(require("convert-source-map"));
+const SOURCE_MAPPING_URL = "sourceMappingURL";
+let preOutputChunk = null;
+function appendSourceMapURLLink(options) {
+  return `${options.code}
+//# ${SOURCE_MAPPING_URL}=${options.filename}.map`;
+}
+function appendSourceMapInline(options) {
+  return `${options.code}
+//# ${SOURCE_MAPPING_URL}=data:application/json;charset=utf-8;base64,${options.map}`;
+}
+function chunkHasChanged(key, chunk) {
+  if (preOutputChunk) {
+    const preChunk = preOutputChunk.get(key);
+    if (preChunk && preChunk.contents === chunk.contents) {
+      return false;
+    }
+  }
+  return true;
+}
+const writeFile = async (compiler) => {
+  for (const [key, value] of compiler.outputChunk.entries()) {
+    if (!chunkHasChanged(key, value)) {
+      continue;
+    }
+    const absPath = import_path.default.resolve(compiler.config.outDir, key);
+    await import_utils.fs.ensureDir(import_path.default.dirname(absPath));
+    if (value.type === "chunk" && value.map) {
+      if (compiler.config.sourceMap === false || compiler.config.sourceMap === "external") {
+        await import_utils.fs.writeFile(absPath, value.contents);
+      } else if (compiler.config.sourceMap === true) {
+        await import_utils.fs.writeFile(absPath, appendSourceMapURLLink({
+          code: value.contents,
+          filename: import_path.default.basename(absPath)
+        }));
+      } else if (compiler.config.sourceMap === "inline") {
+        await import_utils.fs.writeFile(absPath, appendSourceMapInline({
+          code: value.contents,
+          map: import_convert_source_map.default.fromObject(value.map).toBase64()
+        }));
+      }
+      if (compiler.config.sourceMap === true || compiler.config.sourceMap === "external") {
+        await import_utils.fs.writeFile(`${absPath}.map`, JSON.stringify(value.map));
+      }
+    } else {
+      await import_utils.fs.writeFile(absPath, value.contents);
+    }
+  }
+  preOutputChunk = compiler.outputChunk;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  writeFile
+});

package/dist/builder/feature/asset.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { ICompiler, LoadResult, SvgrOptions } from '../../types';
+export declare const asset: {
+  name: string;
+  apply(compiler: ICompiler): void;
+};
+/**
+ *
+ * @param this Compiler
+ * @param assetPath Absolute path of the asset
+ * @param rebaseFrom Absolute path of the file which use asset
+ * @param calledOnLoad called in load hooks
+ * @returns dataurl or path
+ */
+export declare function getAssetContents(this: ICompiler, assetPath: string, rebaseFrom: string, calledOnLoad?: boolean): Promise<{
+  contents: string | Buffer;
+  loader: "copy" | "text";
+}>;
+export declare function loadSvgr(path: string, options: boolean | SvgrOptions): Promise<LoadResult | undefined>;

package/dist/builder/feature/asset.js

@@ -0,0 +1,149 @@
+"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 name2 in all)
+    __defProp(target, name2, { get: all[name2], 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 asset_exports = {};
+__export(asset_exports, {
+  asset: () => asset,
+  getAssetContents: () => getAssetContents,
+  loadSvgr: () => loadSvgr
+});
+module.exports = __toCommonJS(asset_exports);
+var import_path = require("path");
+var import_fs = __toESM(require("fs"));
+var import_pluginutils = require("@rollup/pluginutils");
+var import_core = require("@svgr/core");
+var import_plugin_svgo = __toESM(require("@svgr/plugin-svgo"));
+var import_plugin_jsx = __toESM(require("@svgr/plugin-jsx"));
+var import_file = require("../../constants/file");
+var import_utils = require("../../utils");
+const name = "asset";
+const SVG_REGEXP = /\.svg$/;
+const asset = {
+  name,
+  apply(compiler) {
+    compiler.hooks.load.tapPromise({
+      name
+    }, async (args) => {
+      if (import_file.assetExt.find((ext) => ext === (0, import_path.extname)(args.path))) {
+        const { buildType, outDir, sourceDir, asset: asset2 } = compiler.config;
+        const svgrResult = await loadSvgr(args.path, asset2.svgr);
+        if (svgrResult) {
+          return svgrResult;
+        }
+        const rebaseFrom = buildType === "bundle" ? outDir : (0, import_path.join)(outDir, (0, import_path.relative)(sourceDir, (0, import_path.dirname)(args.path)));
+        const { contents, loader } = await getAssetContents.apply(compiler, [
+          args.path,
+          rebaseFrom,
+          true
+        ]);
+        return {
+          contents,
+          loader
+        };
+      }
+    });
+  }
+};
+function encodeSVG(buffer) {
+  return encodeURIComponent(buffer.toString("utf-8").replace(/[\n\r]/gim, "").replace(/\t/gim, " ").replace(/<!--(.*(?=-->))-->/gim, "").replace(/'/gim, "\\i")).replace(/\(/g, "%28").replace(/\)/g, "%29");
+}
+async function getAssetContents(assetPath, rebaseFrom, calledOnLoad) {
+  const fileContent = await import_fs.default.promises.readFile(assetPath);
+  const { buildType, format, outDir } = this.config;
+  const { limit, path, publicPath } = this.config.asset;
+  const hash = (0, import_utils.getHash)(fileContent, null).slice(0, 8);
+  const outputFileName = (0, import_path.basename)(assetPath).split(".").join(`.${hash}.`);
+  const outputFilePath = (0, import_path.resolve)(outDir, path, outputFileName);
+  const relativePath = (0, import_path.relative)(rebaseFrom, outputFilePath);
+  const normalizedRelativePath = (0, import_utils.normalizeSlashes)(relativePath.startsWith("..") ? relativePath : `./${relativePath}`);
+  const normalizedPublicPath = `${typeof publicPath === "function" ? publicPath(assetPath) : publicPath}${path}/${outputFileName}`;
+  let emitAsset = true;
+  let contents = normalizedPublicPath;
+  let loader = "text";
+  if (buildType === "bundle") {
+    if (fileContent.length <= limit) {
+      const mimetype = (await Promise.resolve().then(() => __toESM(require("@modern-js/utils/mime-types")))).default.lookup(assetPath);
+      const isSVG = mimetype === "image/svg+xml";
+      const data = isSVG ? encodeSVG(fileContent) : fileContent.toString("base64");
+      const encoding = isSVG ? "" : ";base64";
+      contents = `data:${mimetype}${encoding},${data}`;
+      loader = "text";
+      emitAsset = false;
+    } else if ((format === "esm" || format === "cjs") && !publicPath) {
+      contents = calledOnLoad ? fileContent : normalizedRelativePath;
+      loader = calledOnLoad ? "copy" : "text";
+      emitAsset = !calledOnLoad;
+    }
+  } else {
+    contents = normalizedRelativePath;
+  }
+  if (emitAsset) {
+    this.emitAsset(outputFilePath, {
+      type: "asset",
+      fileName: outputFilePath,
+      contents: fileContent,
+      originalFileName: assetPath
+    });
+  }
+  return {
+    contents,
+    loader
+  };
+}
+async function loadSvgr(path, options) {
+  if (!options) {
+    return;
+  }
+  const config = typeof options === "boolean" ? {} : options;
+  const filter = (0, import_pluginutils.createFilter)(config.include || SVG_REGEXP, config.exclude);
+  if (!filter(path)) {
+    return;
+  }
+  const loader = "jsx";
+  const text = import_fs.default.readFileSync(path, "utf8");
+  const jsCode = await (0, import_core.transform)(text, config, {
+    filePath: path,
+    caller: {
+      name: "svgr",
+      defaultPlugins: [
+        import_plugin_svgo.default,
+        import_plugin_jsx.default
+      ]
+    }
+  });
+  return {
+    contents: jsCode,
+    loader
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asset,
+  getAssetContents,
+  loadSvgr
+});

package/dist/builder/feature/format-cjs.d.ts

@@ -0,0 +1,5 @@
+import { ICompiler } from '../../types';
+export declare const formatCjs: {
+  name: string;
+  apply: (compiler: ICompiler) => void;
+};

package/dist/builder/feature/format-cjs.js

@@ -0,0 +1,53 @@
+"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 name2 in all)
+    __defProp(target, name2, { get: all[name2], 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 format_cjs_exports = {};
+__export(format_cjs_exports, {
+  formatCjs: () => formatCjs
+});
+module.exports = __toCommonJS(format_cjs_exports);
+var import_sucrase = require("sucrase");
+const name = "format-cjs";
+const apply = (compiler) => {
+  compiler.hooks.renderChunk.tapPromise({
+    name
+  }, async (chunk) => {
+    if (chunk.fileName.endsWith(".js") && chunk.type === "chunk") {
+      const code = chunk.contents.toString();
+      const result = (0, import_sucrase.transform)(code, {
+        transforms: [
+          "imports"
+        ]
+      });
+      return {
+        ...chunk,
+        contents: result.code,
+        map: result.sourceMap
+      };
+    }
+    return chunk;
+  });
+};
+const formatCjs = {
+  name,
+  apply
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatCjs
+});

package/dist/builder/feature/index.d.ts

@@ -0,0 +1,2 @@
+import { HookList, Context } from '../../types';
+export declare function getInternalList(context: Context): Promise<HookList>;

package/dist/builder/feature/index.js

@@ -0,0 +1,74 @@
+"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 feature_exports = {};
+__export(feature_exports, {
+  getInternalList: () => getInternalList
+});
+module.exports = __toCommonJS(feature_exports);
+var import_dts = require("../../utils/dts");
+var import_format_cjs = require("./format-cjs");
+var import_style = require("./style");
+var import_terser = require("./terser");
+var import_asset = require("./asset");
+async function getInternalList(context) {
+  var _userTsconfig_compilerOptions;
+  const internal = [];
+  const { config } = context;
+  internal.push(import_asset.asset, import_style.css);
+  if (config.buildType === "bundle" && config.format === "cjs" && config.splitting) {
+    internal.push(import_format_cjs.formatCjs);
+  }
+  if (config.buildType === "bundleless") {
+    const { redirect } = await Promise.resolve().then(() => __toESM(require("./redirect")));
+    const { json } = await Promise.resolve().then(() => __toESM(require("./json")));
+    internal.push(redirect, json);
+  }
+  const userTsconfig = await (0, import_dts.getProjectTsconfig)(context.config.tsconfig);
+  var _userTsconfig_compilerOptions_emitDecoratorMetadata;
+  const emitDecoratorMetadata = (_userTsconfig_compilerOptions_emitDecoratorMetadata = userTsconfig === null || userTsconfig === void 0 ? void 0 : (_userTsconfig_compilerOptions = userTsconfig.compilerOptions) === null || _userTsconfig_compilerOptions === void 0 ? void 0 : _userTsconfig_compilerOptions.emitDecoratorMetadata) !== null && _userTsconfig_compilerOptions_emitDecoratorMetadata !== void 0 ? _userTsconfig_compilerOptions_emitDecoratorMetadata : false;
+  const { transformImport, transformLodash, externalHelpers, format, target } = context.config;
+  const enbaleSwcTransform = transformImport.length > 0 || transformLodash || externalHelpers || emitDecoratorMetadata;
+  const enableSwcRenderChunk = enbaleSwcTransform ? format === "umd" : format === "umd" || target === "es5";
+  if (enbaleSwcTransform) {
+    const { swcTransform } = await Promise.resolve().then(() => __toESM(require("./swc")));
+    internal.push(swcTransform(userTsconfig));
+  }
+  if (enableSwcRenderChunk) {
+    const { swcRenderChunk } = await Promise.resolve().then(() => __toESM(require("./swc")));
+    internal.push(swcRenderChunk);
+  }
+  if (config.minify && config.minify !== "esbuild") {
+    internal.push(import_terser.minify);
+  }
+  return internal;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getInternalList
+});

package/dist/builder/feature/json.d.ts

@@ -0,0 +1,5 @@
+import { ICompiler } from '../../types';
+export declare const json: {
+  name: string;
+  apply(compiler: ICompiler): void;
+};

package/dist/builder/feature/json.js

@@ -0,0 +1,47 @@
+"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 name2 in all)
+    __defProp(target, name2, { get: all[name2], 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 json_exports = {};
+__export(json_exports, {
+  json: () => json
+});
+module.exports = __toCommonJS(json_exports);
+var import_fs = require("fs");
+const isJsonExt = (path) => {
+  return path.endsWith(".json");
+};
+const name = "json";
+const json = {
+  name,
+  apply(compiler) {
+    compiler.hooks.load.tapPromise({
+      name
+    }, async (args) => {
+      if (isJsonExt(args.path)) {
+        return {
+          contents: (0, import_fs.readFileSync)(args.path),
+          loader: "copy"
+        };
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  json
+});

package/dist/builder/feature/redirect.d.ts

@@ -0,0 +1,5 @@
+import { ICompiler } from '../../types';
+export declare const redirect: {
+  name: string;
+  apply(compiler: ICompiler): void;
+};