@modern-js/module-tools 2.35.0 → 2.36.0

package/dist/builder/copy.js

@@ -1,54 +1,66 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  runPatterns: function() {
-    return runPatterns;
-  },
-  watchCopyFiles: function() {
-    return watchCopyFiles;
-  },
-  copyTask: function() {
-    return copyTask;
+    __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 copy_exports = {};
+__export(copy_exports, {
+  copyTask: () => copyTask,
+  runPatterns: () => runPatterns,
+  watchCopyFiles: () => watchCopyFiles
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _utils = require("@modern-js/utils");
-const _pmap = /* @__PURE__ */ _interop_require_default._(require("../../compiled/p-map"));
+module.exports = __toCommonJS(copy_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_p_map = __toESM(require("../../compiled/p-map"));
+var import_debug = require("../debug");
 const watchMap = /* @__PURE__ */ new Map();
 const runPatterns = async (pattern, options) => {
-  const { default: normalizePath } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../../compiled/normalize-path")));
+  const { default: normalizePath } = await Promise.resolve().then(() => __toESM(require("../../compiled/normalize-path")));
   const { appDirectory, enableCopySync = false } = options;
   const { from, globOptions = {} } = pattern;
   const targetPattern = {
     ...pattern
   };
-  const normalizedFrom = _path.default.normalize(from);
+  const normalizedFrom = import_path.default.normalize(from);
   const defaultAbsContext = options.defaultContext;
   if (typeof pattern.context === "string") {
-    targetPattern.context = _path.default.isAbsolute(pattern.context) ? pattern.context : _path.default.join(appDirectory, pattern.context);
+    targetPattern.context = import_path.default.isAbsolute(pattern.context) ? pattern.context : import_path.default.join(appDirectory, pattern.context);
   } else {
     targetPattern.context = defaultAbsContext;
   }
   let absoluteFrom;
-  if (_path.default.isAbsolute(normalizedFrom)) {
+  if (import_path.default.isAbsolute(normalizedFrom)) {
     absoluteFrom = normalizedFrom;
   } else {
-    absoluteFrom = _path.default.resolve(targetPattern.context, normalizedFrom);
+    absoluteFrom = import_path.default.resolve(targetPattern.context, normalizedFrom);
   }
   let stats;
   try {
-    stats = await _utils.fs.stat(absoluteFrom);
+    stats = await import_utils.fs.stat(absoluteFrom);
   } catch (error) {
   }
   let fromType;
@@ -67,15 +79,15 @@ const runPatterns = async (pattern, options) => {
   switch (fromType) {
     case "dir":
       targetPattern.context = absoluteFrom;
-      glob = _path.default.posix.join(_utils.fastGlob.escapePath(normalizePath(_path.default.resolve(absoluteFrom))), "**/*");
-      absoluteFrom = _path.default.join(absoluteFrom, "**/*");
+      glob = import_path.default.posix.join(import_utils.fastGlob.escapePath(normalizePath(import_path.default.resolve(absoluteFrom))), "**/*");
+      absoluteFrom = import_path.default.join(absoluteFrom, "**/*");
       if (typeof globOptions.dot === "undefined") {
         globOptions.dot = true;
       }
       break;
     case "file":
-      targetPattern.context = _path.default.dirname(absoluteFrom);
-      glob = _utils.fastGlob.escapePath(normalizePath(_path.default.resolve(absoluteFrom)));
+      targetPattern.context = import_path.default.dirname(absoluteFrom);
+      glob = import_utils.fastGlob.escapePath(normalizePath(import_path.default.resolve(absoluteFrom)));
       if (typeof globOptions.dot === "undefined") {
         globOptions.dot = true;
       }
@@ -83,10 +95,10 @@ const runPatterns = async (pattern, options) => {
     case "glob":
     default: {
       var _targetPattern_context;
-      glob = _path.default.isAbsolute(from) ? from : _path.default.posix.join(_utils.fastGlob.escapePath(normalizePath(_path.default.resolve((_targetPattern_context = targetPattern.context) !== null && _targetPattern_context !== void 0 ? _targetPattern_context : appDirectory))), from);
+      glob = import_path.default.isAbsolute(from) ? from : import_path.default.posix.join(import_utils.fastGlob.escapePath(normalizePath(import_path.default.resolve((_targetPattern_context = targetPattern.context) !== null && _targetPattern_context !== void 0 ? _targetPattern_context : appDirectory))), from);
     }
   }
-  const globEntries = await (0, _utils.globby)(glob, {
+  const globEntries = await (0, import_utils.globby)(glob, {
     ...{
       followSymbolicLinks: true
     },
@@ -94,64 +106,62 @@ const runPatterns = async (pattern, options) => {
     cwd: targetPattern.context,
     objectMode: true
   });
-  (0, _pmap.default)(globEntries, async (globEntry) => {
+  (0, import_p_map.default)(globEntries, async (globEntry) => {
     if (!globEntry.dirent.isFile()) {
       return;
     }
     const from2 = globEntry.path;
-    const absoluteFrom2 = _path.default.resolve(targetPattern.context, from2);
-    const to = _path.default.normalize(typeof targetPattern.to !== "undefined" ? targetPattern.to : "");
-    const toType = _path.default.extname(to) === "" || to.slice(-1) === _path.default.sep ? "dir" : "file";
+    const absoluteFrom2 = import_path.default.resolve(targetPattern.context, from2);
+    const to = import_path.default.normalize(typeof targetPattern.to !== "undefined" ? targetPattern.to : "");
+    const toType = import_path.default.extname(to) === "" || to.slice(-1) === import_path.default.sep ? "dir" : "file";
     var _targetPattern_context2;
-    const relativeFrom = _path.default.relative((_targetPattern_context2 = targetPattern.context) !== null && _targetPattern_context2 !== void 0 ? _targetPattern_context2 : defaultAbsContext, absoluteFrom2);
-    const filename = toType === "dir" ? _path.default.join(to, relativeFrom) : to;
-    const absoluteTo = _path.default.isAbsolute(filename) ? filename : _path.default.join(options.outDir, filename);
+    const relativeFrom = import_path.default.relative((_targetPattern_context2 = targetPattern.context) !== null && _targetPattern_context2 !== void 0 ? _targetPattern_context2 : defaultAbsContext, absoluteFrom2);
+    const filename = toType === "dir" ? import_path.default.join(to, relativeFrom) : to;
+    const absoluteTo = import_path.default.isAbsolute(filename) ? filename : import_path.default.join(options.outDir, filename);
     if (options.watch) {
       watchMap.set(absoluteFrom2, absoluteTo);
     }
     if (enableCopySync) {
-      _utils.fs.copySync(absoluteFrom2, absoluteTo);
+      import_utils.fs.copySync(absoluteFrom2, absoluteTo);
     } else {
-      await _utils.fs.copy(absoluteFrom2, absoluteTo);
+      await import_utils.fs.copy(absoluteFrom2, absoluteTo);
     }
   });
 };
 const watchCopyFiles = async (options, copyConfig) => {
-  const debug = (0, _utils.createDebugger)("module-tools:copy-watch");
-  debug("watchMap", watchMap);
-  const { SectionTitleStatus, CopyLogPrefix } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../constants/log")));
-  const { watchSectionTitle } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../utils/log")));
+  (0, import_debug.debug)("watchMap", watchMap);
   const watchList = Array.from(watchMap.keys());
-  debug("watchList", watchList);
-  (0, _utils.watch)(watchList, async ({ changedFilePath, changeType }) => {
-    var _copyConfig_options, _copyConfig;
+  (0, import_debug.debug)("watchList", watchList);
+  (0, import_utils.watch)(watchList, async ({ changedFilePath, changeType }) => {
+    var _copyConfig_options;
     const result = watchMap.get(changedFilePath);
     if (!result) {
       return;
     }
-    const formatFilePath = _path.default.relative(options.appDirectory, changedFilePath);
+    const formatFilePath = import_path.default.relative(options.appDirectory, changedFilePath);
     if (changeType === "unlink") {
-      _utils.fs.remove(result);
-      _utils.logger.log(await watchSectionTitle(CopyLogPrefix, SectionTitleStatus.Log, `${formatFilePath} removed`));
+      import_utils.fs.remove(result);
+      import_utils.logger.info(`Copied file removed: ${import_utils.chalk.dim(formatFilePath)}`);
       return;
     }
-    if ((_copyConfig = copyConfig) === null || _copyConfig === void 0 ? void 0 : (_copyConfig_options = _copyConfig.options) === null || _copyConfig_options === void 0 ? void 0 : _copyConfig_options.enableCopySync) {
-      _utils.fs.copySync(changedFilePath, result);
+    if (copyConfig === null || copyConfig === void 0 ? void 0 : (_copyConfig_options = copyConfig.options) === null || _copyConfig_options === void 0 ? void 0 : _copyConfig_options.enableCopySync) {
+      import_utils.fs.copySync(changedFilePath, result);
     } else {
-      await _utils.fs.copy(changedFilePath, result);
+      await import_utils.fs.copy(changedFilePath, result);
     }
-    _utils.logger.log(await watchSectionTitle(CopyLogPrefix, SectionTitleStatus.Log, `${formatFilePath} changed`));
+    import_utils.logger.info(`Copy file: ${import_utils.chalk.dim(formatFilePath)}`);
   });
 };
 const copyTask = async (buildConfig, options) => {
-  var _copyConfig_options, _copyConfig;
+  var _copyConfig_options;
   const copyConfig = buildConfig.copy;
   if (!copyConfig.patterns || copyConfig.patterns.length === 0) {
     return;
   }
-  const concurrency = ((_copyConfig = copyConfig) === null || _copyConfig === void 0 ? void 0 : (_copyConfig_options = _copyConfig.options) === null || _copyConfig_options === void 0 ? void 0 : _copyConfig_options.concurrency) || 100;
+  (0, import_debug.debug)("run copy task");
+  const concurrency = (copyConfig === null || copyConfig === void 0 ? void 0 : (_copyConfig_options = copyConfig.options) === null || _copyConfig_options === void 0 ? void 0 : _copyConfig_options.concurrency) || 100;
   try {
-    await (0, _pmap.default)(copyConfig.patterns, async (copyOption) => {
+    await (0, import_p_map.default)(copyConfig.patterns, async (copyOption) => {
       var _copyConfig_options2;
       await runPatterns(copyOption, {
         ...options,
@@ -164,12 +174,17 @@ const copyTask = async (buildConfig, options) => {
     });
   } catch (e) {
     if (e instanceof Error) {
-      _utils.logger.error(`copy error: ${e.message}`);
+      import_utils.logger.error(`copy error: ${e.message}`);
     }
   }
+  (0, import_debug.debug)("run copy task done");
   if (options.watch) {
     await watchCopyFiles(options, copyConfig);
   }
 };
-
-//# sourceMappingURL=copy.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  copyTask,
+  runPatterns,
+  watchCopyFiles
+});

package/dist/builder/dts/index.js

@@ -1,23 +1,31 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  runRollup: function() {
-    return _rollup.runRollup;
-  },
-  runTsc: function() {
-    return _tsc.runTsc;
+    __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 dts_exports = {};
+__export(dts_exports, {
+  runRollup: () => import_rollup.runRollup,
+  runTsc: () => import_tsc.runTsc
+});
+module.exports = __toCommonJS(dts_exports);
+var import_rollup = require("./rollup");
+var import_tsc = require("./tsc");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runRollup,
+  runTsc
 });
-const _rollup = require("./rollup");
-const _tsc = require("./tsc");
-
-//# sourceMappingURL=index.js.map

package/dist/builder/dts/rollup.d.ts

@@ -1,23 +1,15 @@
 import type { RollupWatcher } from '../../../compiled/rollup';
-import type { BaseBuildConfig, Input, PluginAPI, ModuleTools } from '../../types';
+import type { GeneratorDtsConfig, PluginAPI, ModuleTools } from '../../types';
 export type { RollupWatcher };
-type Config = {
-  distDir: string;
-  tsconfigPath: string;
-  externals: BaseBuildConfig['externals'];
-  input: Input;
-  watch: boolean;
-  abortOnError: boolean;
-  respectExternal: boolean;
-  appDirectory: string;
-};
 export declare const runRollup: (api: PluginAPI<ModuleTools>, {
-  distDir,
+  distPath,
   tsconfigPath,
   externals,
   input,
   watch,
   abortOnError,
   respectExternal,
-  appDirectory
-}: Config) => Promise<RollupWatcher | import("../../../compiled/rollup").RollupBuild | null>;
+  appDirectory,
+  footer,
+  banner
+}: GeneratorDtsConfig) => Promise<RollupWatcher | import("../../../compiled/rollup").RollupBuild | null>;

package/dist/builder/dts/rollup.js

@@ -1,22 +1,43 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "runRollup", {
-  enumerable: true,
-  get: function() {
-    return runRollup;
+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 rollup_exports = {};
+__export(rollup_exports, {
+  runRollup: () => runRollup
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _logger = require("@modern-js/utils/logger");
-const _typescript = /* @__PURE__ */ _interop_require_default._(require("typescript"));
-const _pluginjson = /* @__PURE__ */ _interop_require_default._(require("../../../compiled/@rollup/plugin-json"));
-const _rollupplugindts = /* @__PURE__ */ _interop_require_default._(require("../../../compiled/rollup-plugin-dts"));
-const _common = require("../../utils/common");
-const runRollup = async (api, { distDir, tsconfigPath, externals, input, watch, abortOnError, respectExternal, appDirectory }) => {
+module.exports = __toCommonJS(rollup_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_typescript = __toESM(require("typescript"));
+var import_plugin_json = __toESM(require("../../../compiled/@rollup/plugin-json"));
+var import_rollup_plugin_dts = __toESM(require("../../../compiled/rollup-plugin-dts"));
+var import_utils2 = require("../../utils");
+const runRollup = async (api, { distPath, tsconfigPath, externals, input, watch, abortOnError, respectExternal, appDirectory, footer, banner }) => {
   const ignoreFiles = {
     name: "ignore-files",
     load(id) {
@@ -26,24 +47,24 @@ const runRollup = async (api, { distDir, tsconfigPath, externals, input, watch,
       return null;
     }
   };
-  const configFile = _typescript.default.readConfigFile(tsconfigPath, _typescript.default.sys.readFile);
-  const { options } = _typescript.default.parseJsonConfigFileContent(configFile.config, _typescript.default.sys, "./");
-  const baseUrl = _path.default.isAbsolute(options.baseUrl || ".") ? options.baseUrl : _path.default.join(_path.default.dirname(tsconfigPath), options.baseUrl || ".");
+  const configFile = import_typescript.default.readConfigFile(tsconfigPath, import_typescript.default.sys.readFile);
+  const { options } = import_typescript.default.parseJsonConfigFileContent(configFile.config, import_typescript.default.sys, "./");
+  const baseUrl = import_path.default.isAbsolute(options.baseUrl || ".") ? options.baseUrl : import_path.default.join(import_path.default.dirname(tsconfigPath), options.baseUrl || ".");
   const ignoreCompileOptions = [
     "incremental",
     "tsBuildInfoFile",
     "sourceMap",
     "inlineSources"
   ];
-  const resolveRelative = (p) => _path.default.resolve(appDirectory, p);
-  const dtsInput = Array.isArray(input) ? input.map(resolveRelative) : (0, _common.mapValue)(input, resolveRelative);
+  const resolveRelative = (p) => import_path.default.resolve(appDirectory, p);
+  const dtsInput = Array.isArray(input) ? input.map(resolveRelative) : (0, import_utils2.mapValue)(input, resolveRelative);
   const inputConfig = {
     input: dtsInput,
     external: externals,
     plugins: [
-      (0, _pluginjson.default)(),
+      (0, import_plugin_json.default)(),
       ignoreFiles,
-      (0, _rollupplugindts.default)({
+      (0, import_rollup_plugin_dts.default)({
         respectExternal,
         compilerOptions: {
           skipLibCheck: true,
@@ -67,22 +88,22 @@ const runRollup = async (api, { distDir, tsconfigPath, externals, input, watch,
           // Avoid extra work
           checkJs: false,
           // Ensure we can parse the latest code
-          target: _typescript.default.ScriptTarget.ESNext,
-          ...(0, _common.transformUndefineObject)(ignoreCompileOptions)
+          target: import_typescript.default.ScriptTarget.ESNext,
+          ...(0, import_utils2.transformUndefineObject)(ignoreCompileOptions)
         },
         tsconfig: tsconfigPath
       })
     ].filter(Boolean)
   };
   const outputConfig = {
-    dir: distDir,
+    dir: distPath,
     format: "esm",
-    exports: "named"
+    exports: "named",
+    footer,
+    banner
   };
   if (watch) {
-    const { watch: watch2 } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../../../compiled/rollup")));
-    const { watchSectionTitle } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../../utils/log")));
-    const { SectionTitleStatus, BundleDtsLogPrefix } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../../constants/log")));
+    const { watch: watch2 } = await Promise.resolve().then(() => __toESM(require("../../../compiled/rollup")));
     const runner = api.useHookRunners();
     const watcher = watch2({
       ...inputConfig,
@@ -90,9 +111,9 @@ const runRollup = async (api, { distDir, tsconfigPath, externals, input, watch,
       output: outputConfig
     }).on("event", async (event) => {
       if (event.code === "START") {
-        _logger.logger.info(await watchSectionTitle(BundleDtsLogPrefix, SectionTitleStatus.Log));
+        import_utils.logger.info((0, import_utils2.withLogTitle)("bundle", "Start build types..."));
       } else if (event.code === "BUNDLE_END") {
-        _logger.logger.info(await watchSectionTitle(BundleDtsLogPrefix, SectionTitleStatus.Success));
+        import_utils.logger.success((0, import_utils2.withLogTitle)("bundle", "Build types"));
         runner.buildWatchDts({
           buildType: "bundle"
         });
@@ -102,14 +123,14 @@ const runRollup = async (api, { distDir, tsconfigPath, externals, input, watch,
     return watcher;
   } else {
     try {
-      const { rollup } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../../../compiled/rollup")));
-      const { addRollupChunk } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../../utils/print")));
+      const { rollup } = await Promise.resolve().then(() => __toESM(require("../../../compiled/rollup")));
+      const { addRollupChunk } = await Promise.resolve().then(() => __toESM(require("../../utils")));
       const bundle = await rollup(inputConfig);
       const rollupOutput = await bundle.write(outputConfig);
       addRollupChunk(rollupOutput, appDirectory, outputConfig.dir);
       return bundle;
     } catch (e) {
-      const { printOrThrowDtsErrors } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../../utils/dts")));
+      const { printOrThrowDtsErrors } = await Promise.resolve().then(() => __toESM(require("../../utils")));
       await printOrThrowDtsErrors(e, {
         abortOnError,
         buildType: "bundle"
@@ -118,5 +139,7 @@ const runRollup = async (api, { distDir, tsconfigPath, externals, input, watch,
     }
   }
 };
-
-//# sourceMappingURL=rollup.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runRollup
+});

package/dist/builder/dts/tsc.d.ts

@@ -1,2 +1,3 @@
-import type { BundlelessGeneratorDtsConfig, PluginAPI, ModuleTools } from '../../types';
-export declare const runTsc: (api: PluginAPI<ModuleTools>, config: BundlelessGeneratorDtsConfig) => Promise<void>;
+import type { GeneratorDtsConfig, PluginAPI, ModuleTools } from '../../types';
+export declare const removeTscLogTime: (log: string) => string;
+export declare const runTsc: (api: PluginAPI<ModuleTools>, config: GeneratorDtsConfig) => Promise<void>;

package/dist/builder/dts/tsc.js

@@ -1,48 +1,60 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "runTsc", {
-  enumerable: true,
-  get: function() {
-    return runTsc;
+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 tsc_exports = {};
+__export(tsc_exports, {
+  removeTscLogTime: () => removeTscLogTime,
+  runTsc: () => runTsc
 });
-const _utils = require("@modern-js/utils");
-const _print = require("../../utils/print");
-const _dts = require("../../utils/dts");
-const _log = require("../../utils/log");
-const _log1 = require("../../constants/log");
-const _dts1 = require("../../constants/dts");
+module.exports = __toCommonJS(tsc_exports);
+var import_utils = require("@modern-js/utils");
+var import_utils2 = require("../../utils");
+var import_dts = require("../../constants/dts");
+const removeTscLogTime = (log) => log.replace(/\[.*\]\s/, "");
 const resolveLog = async (childProgress, options) => {
   var _childProgress_stdout, _childProgress_stdout1, _childProgress_stderr;
   const { watch = false, watchFn = async () => void 0 } = options;
   (_childProgress_stdout = childProgress.stdout) === null || _childProgress_stdout === void 0 ? void 0 : _childProgress_stdout.on("data", async (data) => {
     if (watch) {
-      _utils.logger.info(await (0, _log.watchSectionTitle)(_log1.BundlelessDtsLogPrefix, _log1.SectionTitleStatus.Log));
-      _utils.logger.info(data.toString());
-      if (data.toString().includes(_dts1.watchDoneText)) {
+      const lines = data.toString().split("\n").filter((line) => line.trim() !== "").map((line) => (0, import_utils2.withLogTitle)("tsc", removeTscLogTime(line)));
+      import_utils.logger.info(lines.join("\n"));
+      if (data.toString().includes(import_dts.watchDoneText)) {
         await watchFn();
       }
     }
   });
   (_childProgress_stdout1 = childProgress.stdout) === null || _childProgress_stdout1 === void 0 ? void 0 : _childProgress_stdout1.on("error", (error) => {
-    _utils.logger.error(error.message);
+    import_utils.logger.error(error.message);
   });
   (_childProgress_stderr = childProgress.stderr) === null || _childProgress_stderr === void 0 ? void 0 : _childProgress_stderr.on("data", (chunk) => {
-    _utils.logger.error(chunk.toString());
+    import_utils.logger.error(chunk.toString());
   });
 };
-const generatorDts = async (api, config) => {
+const runTscBin = async (api, config, info) => {
   const { appDirectory, watch = false, abortOnError = true } = config;
-  const { userTsconfig, generatedTsconfig: result } = await (0, _dts.generatorTsConfig)(config);
-  const tscBinFile = await (0, _dts.getTscBinPath)(appDirectory);
+  const { tempTsconfigPath } = info;
+  const tscBinFile = await (0, import_utils2.getTscBinPath)(appDirectory);
   const watchParams = watch ? [
     "-w"
   ] : [];
-  const childProgress = (0, _utils.execa)(tscBinFile, [
+  const childProgress = (0, import_utils.execa)(tscBinFile, [
     "-p",
-    result.tempTsconfigPath,
+    tempTsconfigPath,
     /* Required parameter, use it stdout have color */
     "--pretty",
     // https://github.com/microsoft/TypeScript/issues/21824
@@ -56,10 +68,9 @@ const generatorDts = async (api, config) => {
   resolveLog(childProgress, {
     watch,
     watchFn: async () => {
-      await (0, _dts.resolveAlias)(config, {
-        ...result,
-        userTsconfig
-      });
+      const result = await (0, import_utils2.resolveAlias)(config, info);
+      const dtsFiles = (0, import_utils2.addBannerAndFooter)(result, config.banner, config.footer);
+      await (0, import_utils2.writeDtsFiles)(config, info, dtsFiles);
       runner.buildWatchDts({
         buildType: "bundleless"
       });
@@ -68,20 +79,22 @@ const generatorDts = async (api, config) => {
   try {
     await childProgress;
   } catch (e) {
-    await (0, _dts.printOrThrowDtsErrors)(e, {
+    await (0, import_utils2.printOrThrowDtsErrors)(e, {
       abortOnError,
       buildType: "bundleless"
     });
   }
-  return {
-    ...result,
-    userTsconfig
-  };
 };
 const runTsc = async (api, config) => {
-  const result = await generatorDts(api, config);
-  await (0, _dts.resolveAlias)(config, result);
-  await (0, _print.addDtsFiles)(config.distAbsPath, config.appDirectory);
+  const generatedDtsInfo = await (0, import_utils2.generateDtsInfo)(config);
+  await runTscBin(api, config, generatedDtsInfo);
+  const result = await (0, import_utils2.resolveAlias)(config, generatedDtsInfo);
+  const dtsFiles = (0, import_utils2.addBannerAndFooter)(result, config.banner, config.footer);
+  await (0, import_utils2.writeDtsFiles)(config, generatedDtsInfo, dtsFiles);
+  await (0, import_utils2.addDtsFiles)(config.distPath, config.appDirectory);
 };
-
-//# sourceMappingURL=tsc.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  removeTscLogTime,
+  runTsc
+});

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

@@ -0,0 +1,3 @@
+import { Plugin } from 'esbuild';
+import type { ICompiler } from '../../types';
+export declare const adapterPlugin: (compiler: ICompiler) => Plugin;