@modern-js/module-tools 2.35.0 → 2.36.0

package/dist/types/config/index.d.ts

@@ -1,21 +1,51 @@
-import type { UserConfig as LibuildUserConfig, Asset as LibuildAsset, Style as LibuildStyle } from '@modern-js/libuild';
-import type { Options } from '@modern-js/libuild-plugin-svgr';
-import type { ImportItem } from '@modern-js/libuild-plugin-swc';
-import type { ToolsConfig as WebpackBuilderToolsConfig } from '@modern-js/builder-webpack-provider';
+import type { BuildOptions } from 'esbuild';
+import type { ImportItem } from '@modern-js/swc-plugins';
+import type { Config } from '@svgr/core';
+import type { CreateFilter } from '@rollup/pluginutils';
+import type { MinifyOptions as TerserMinifyOptions } from 'terser';
 import type { TestConfig } from '@modern-js/types';
 import { internalPreset, presetList } from '../../constants/preset';
+import { ICompiler } from '../esbuild';
 import type { CopyConfig } from './copy';
-import type { LessConfig, SassConfig, PostCSSConfig, TailwindCSSConfig } from './style';
+import type { Dev } from './dev';
+import type { Style, StyleConfig } from './style';
 export * from './style';
+export * from './dev';
+export * from './copy';
+export type HookList = {
+  name: string;
+  apply: (compiler: ICompiler) => void;
+}[];
+export type EsbuildOptions = (options: BuildOptions) => BuildOptions;
 export type BuildType = 'bundleless' | 'bundle';
-export type Format = 'esm' | 'cjs' | 'umd' | 'iife';
 export type Target = 'es5' | 'es6' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'esnext';
-export type Input = Required<LibuildUserConfig>['input'];
+export type Minify = 'esbuild' | 'terser' | false | TerserMinifyOptions;
+export type Format = 'esm' | 'cjs' | 'umd' | 'iife';
+export type Input = {
+  [name: string]: string;
+} | string[];
+export type Globals = Record<any, any>;
+export type Define = Record<string, string>;
+export type Externals = (string | RegExp)[];
+export type Platform = 'node' | 'browser';
+export type SideEffects = RegExp[] | boolean | ((id: string, external: boolean) => boolean);
+/**
+ * @experimental
+ */
+export type Redirect = {
+  alias?: boolean;
+  style?: boolean;
+  asset?: boolean;
+};
 export type DTSOptions = {
   abortOnError: boolean;
   distPath: string;
-  tsconfigPath: string;
   only: boolean;
+  /**
+   * @deprecated
+   * use buildConfig.tsconfig instead.
+   */
+  tsconfigPath?: string;
   /**
    * Only for rollup-plugin-dts, see more in https://github.com/Swatinem/rollup-plugin-dts#what-to-expect.
    * We hope you use external to prevent them(like @types) which come from node_modules from be bundled.
@@ -27,62 +57,88 @@ export type DTSOptions = {
   respectExternal: boolean;
 };
 export type DTS = false | Partial<DTSOptions>;
+export interface SvgrOptions extends Config {
+  include?: Parameters<CreateFilter>[0];
+  exclude?: Parameters<CreateFilter>[1];
+}
 export interface Asset {
-  path?: LibuildAsset['outdir'];
-  limit?: LibuildAsset['limit'];
-  publicPath?: LibuildAsset['publicPath'];
-  svgr?: boolean | Options;
+  path?: string;
+  limit?: number;
+  publicPath?: string | ((filePath: string) => string);
+  svgr?: boolean | SvgrOptions;
 }
-export type SourceMap = Required<LibuildUserConfig>['sourceMap'];
 export type AutoExternal = boolean | {
   dependencies?: boolean;
   peerDependencies?: boolean;
 };
-export type JSX = 'automatic' | 'transform';
+export type JSX = 'automatic' | 'transform' | 'preserve';
 export type ExternalHelpers = boolean;
+export type BannerAndFooter = {
+  js?: string;
+  css?: string;
+  dts?: string;
+};
 export type AliasOption = Record<string, string> | ((aliases: Record<string, string>) => Record<string, string> | void);
-export type BaseBuildConfig = Omit<Required<PartialBaseBuildConfig>, 'dts' | 'style' | 'alias' | 'sideEffects'> & {
-  sideEffects: LibuildUserConfig['sideEffects'];
+export type Resolve = {
+  mainFields?: string[];
+  jsExtensions?: string[];
+};
+export type BaseBuildConfig = Omit<Required<PartialBaseBuildConfig>, 'dts' | 'style' | 'alias' | 'sideEffects' | 'asset' | 'resolve'> & {
+  sideEffects?: SideEffects;
   dts: false | DTSOptions;
-  style: Omit<Required<LibuildStyle>, 'cleanCss'> & {
-    tailwindcss: TailwindCSSConfig;
-  };
+  style: Style;
   alias: Record<string, string>;
+  asset: Required<Asset>;
+  resolve: Required<Resolve>;
 };
 export type PartialBaseBuildConfig = {
-  sourceType?: 'commonjs' | 'module';
+  resolve?: Resolve;
+  footer?: BannerAndFooter;
+  banner?: BannerAndFooter;
   buildType?: 'bundleless' | 'bundle';
   format?: Format;
   target?: Target;
   dts?: DTS;
-  sourceMap?: SourceMap;
+  sourceMap?: boolean | 'inline' | 'external';
   sourceDir?: string;
   copy?: CopyConfig;
   asset?: Asset;
   jsx?: JSX;
   outDir?: string;
   alias?: AliasOption;
+  hooks?: HookList;
   input?: Input;
+  tsconfig?: string;
   metafile?: boolean;
-  platform?: LibuildUserConfig['platform'];
-  splitting?: LibuildUserConfig['splitting'];
-  minify?: LibuildUserConfig['minify'];
-  externals?: LibuildUserConfig['external'];
+  platform?: Platform;
+  splitting?: boolean;
+  minify?: Minify;
+  externals?: Externals;
   autoExternal?: AutoExternal;
-  umdGlobals?: LibuildUserConfig['globals'];
+  umdGlobals?: Globals;
   umdModuleName?: ((chunkName: string) => string) | string | undefined;
-  define?: LibuildUserConfig['define'];
+  define?: Define;
   style?: StyleConfig;
-  redirect?: LibuildUserConfig['redirect'];
-  sideEffects?: LibuildUserConfig['sideEffects'];
-  esbuildOptions?: LibuildUserConfig['esbuildOptions'];
+  redirect?: Redirect;
+  sideEffects?: SideEffects;
+  esbuildOptions?: EsbuildOptions;
+  /**
+   * @internal
+   * cache transform result or not
+   */
+  transformCache?: boolean;
   externalHelpers?: ExternalHelpers;
   transformImport?: ImportItem[];
   transformLodash?: boolean;
   /**
-   * internal configuration
+   * @deprecated
+   * @internal
    */
   disableSwcTransform?: boolean;
+  /**
+   * @deprecated
+   */
+  sourceType?: 'commonjs' | 'module';
 };
 export type BuildConfig = BaseBuildConfig | BaseBuildConfig[];
 export type PartialBuildConfig = PartialBaseBuildConfig | PartialBaseBuildConfig[];
@@ -90,27 +146,6 @@ export type BuildPreset = keyof typeof presetList | ((options: {
   preset: typeof internalPreset;
   extendPreset: (extendPresetName: keyof typeof internalPreset, extendBuildConfig: PartialBaseBuildConfig) => PartialBaseBuildConfig[];
 }) => PartialBaseBuildConfig[] | Promise<PartialBaseBuildConfig[]>);
-export interface StyleConfig {
-  less?: LessConfig;
-  sass?: SassConfig;
-  postcss?: PostCSSConfig;
-  autoModules?: LibuildStyle['autoModules'];
-  modules?: LibuildStyle['modules'];
-  inject?: LibuildStyle['inject'];
-  /**
-   * The configuration of `tools.tailwindcss` is provided by `tailwindcss` plugin.
-   * Please use `yarn new` or `pnpm new` to enable the corresponding capability.
-   * @requires `tailwindcss` plugin
-   */
-  tailwindcss?: TailwindCSSConfig;
-}
-export interface StorybookBuildConfig {
-  webpack?: WebpackBuilderToolsConfig['webpack'];
-  webpackChain?: WebpackBuilderToolsConfig['webpackChain'];
-}
-export interface Dev {
-  storybook?: StorybookBuildConfig;
-}
 export interface RuntimeUserConfig {
   [name: string]: any;
 }

package/dist/types/config/index.js

@@ -1,8 +1,26 @@
 "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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+module.exports = __toCommonJS(config_exports);
+__reExport(config_exports, require("./style"), module.exports);
+__reExport(config_exports, require("./dev"), module.exports);
+__reExport(config_exports, require("./copy"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./style"),
+  ...require("./dev"),
+  ...require("./copy")
 });
-const _export_star = require("@swc/helpers/_/_export_star");
-_export_star._(require("./style"), exports);
-
-//# sourceMappingURL=index.js.map

package/dist/types/config/style.d.ts

@@ -1,12 +1,64 @@
-import type { Style } from '@modern-js/libuild';
-import type { AcceptedPlugin as PostCSSPlugin } from 'postcss';
-export type LessOptions = Required<Style>['less'];
-export type SassOptions = Required<Style>['sass'];
-export type PostcssOptions = Required<Style>['postcss'];
+import type { AcceptedPlugin as PostCSSPlugin, ProcessOptions, Plugin } from 'postcss';
+import type { Options as sassOptions } from '../../../compiled/sass';
+import Less from '../../../compiled/less';
+type LocalsConventionFunction = (originalClassName: string, generatedClassName: string, inputFile: string) => string;
+type GenerateScopedNameFunction = (name: string, filename: string, css: string) => string;
+declare class Loader {
+  finalSource?: string | undefined;
+  constructor(root: string, plugins: Plugin[]);
+  fetch(file: string, relativeTo: string, depTrace: string): Promise<{
+    [key: string]: string;
+  }>;
+}
+type AdditionalData = string | ((filePath: string) => string);
+export type Modules = {
+  localsConvention?: 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly' | LocalsConventionFunction;
+  scopeBehaviour?: 'global' | 'local';
+  globalModulePaths?: RegExp[];
+  generateScopedName?: string | GenerateScopedNameFunction;
+  hashPrefix?: string;
+  exportGlobals?: boolean;
+  root?: string;
+  resolve?: (file: string) => string | Promise<string>;
+  Loader?: typeof Loader;
+  getJSON?: (cssFilename: string, json: {
+    [name: string]: string;
+  }, outputFilename?: string) => void;
+};
+export type AutoModules = boolean | RegExp;
+export type LessOptions = {
+  additionalData?: AdditionalData;
+  implementation?: object | string;
+  lessOptions?: Less.Options;
+};
+export type SassOptions = {
+  additionalData?: AdditionalData;
+  implementation?: object | string;
+  sassOptions?: sassOptions<'async'>;
+};
+export type PostcssOptions = {
+  processOptions?: ProcessOptions;
+  plugins?: PostCSSPlugin[];
+};
 export type LessConfig = LessOptions | ((options: LessOptions) => LessOptions | void);
 export type SassConfig = SassOptions | ((options: SassOptions) => SassOptions | void);
 export type PostCSSConfigUtils = {
   addPlugins: (plugins: PostCSSPlugin | PostCSSPlugin[]) => void;
 };
 export type PostCSSConfig = PostcssOptions | ((options: PostcssOptions, utils: PostCSSConfigUtils) => PostcssOptions | void);
-export type TailwindCSSConfig = Record<string, any> | ((options: Record<string, any>) => Record<string, any> | void);
+export type TailwindCSSConfig = Record<string, any> | ((options: Record<string, any>) => Record<string, any> | void);
+export interface Style extends Required<StyleConfig> {
+  sass: SassOptions;
+  less: LessOptions;
+  postcss: PostcssOptions;
+}
+export interface StyleConfig {
+  inject?: boolean;
+  sass?: SassConfig;
+  less?: LessConfig;
+  postcss?: PostCSSConfig;
+  autoModules?: boolean | RegExp;
+  modules?: Modules;
+  tailwindcss?: TailwindCSSConfig;
+}
+export {};

package/dist/types/config/style.js

@@ -1,6 +1,16 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-//# sourceMappingURL=style.js.map
+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);
+var style_exports = {};
+module.exports = __toCommonJS(style_exports);

package/dist/types/context.js

@@ -1,6 +1,16 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-//# sourceMappingURL=context.js.map
+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);
+var context_exports = {};
+module.exports = __toCommonJS(context_exports);

package/dist/types/dts.d.ts

@@ -1,12 +1,23 @@
-import type { AliasOption } from './config';
-export interface BundlelessGeneratorDtsConfig {
+import type { AliasOption, BaseBuildConfig, Input } from './config';
+export interface GeneratorDtsConfig {
   appDirectory: string;
-  distAbsPath: string;
   tsconfigPath: string;
   watch: boolean;
   sourceDir: string;
   alias: AliasOption;
   abortOnError?: boolean;
+  footer?: string;
+  banner?: string;
+  distPath: string;
+  externals: BaseBuildConfig['externals'];
+  input: Input;
+  respectExternal: boolean;
+}
+export interface GeneratedDtsInfo {
+  userTsconfig: ITsconfig;
+  tempTsconfigPath: string;
+  tempDistAbsRootPath: string;
+  tempDistAbsSrcPath: string;
 }
 export type TsTarget = 'es3' | 'es5' | 'es6' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'esnext';
 export interface ITsconfig {

package/dist/types/dts.js

@@ -1,6 +1,16 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-//# sourceMappingURL=dts.js.map
+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);
+var dts_exports = {};
+module.exports = __toCommonJS(dts_exports);

package/dist/types/esbuild.d.ts

@@ -0,0 +1,107 @@
+/// <reference types="node" />
+import type { BuildContext, BuildOptions, OnLoadArgs, OnLoadResult, BuildResult, ImportKind } from 'esbuild';
+import type { AsyncSeriesBailHook, AsyncSeriesWaterfallHook } from 'tapable';
+import { FSWatcher } from '@modern-js/utils';
+import { BaseBuildConfig } from './config';
+import { ModuleTools, PluginAPI } from '.';
+export interface SourceMap {
+  mappings: string;
+  names: string[];
+  sources: (string | null)[];
+  version: number;
+  sourcesContent?: (string | null)[];
+}
+export type LoadResult = Pick<OnLoadResult, 'contents' | 'loader' | 'resolveDir'> & {
+  map?: SourceMap;
+};
+export interface BuilderHooks {
+  /**
+   * Equal to esbuild#onLoad
+   */
+  load: AsyncSeriesBailHook<[OnLoadArgs], LoadResult | undefined | void>;
+  /**
+   * Transform code after it is loaded.
+   */
+  transform: AsyncSeriesWaterfallHook<Source>;
+  /**
+   * Modify the chunk
+   */
+  renderChunk: AsyncSeriesWaterfallHook<[Chunk]>;
+}
+export type Context = {
+  config: BaseBuildConfig;
+  watch: boolean;
+  root: string;
+  api: PluginAPI<ModuleTools>;
+};
+export interface ICompiler {
+  reBuild: (type: 'link' | 'change', config: BaseBuildConfig) => Promise<void>;
+  css_resolve: (id: string, dir: string) => string;
+  node_resolve: (id: string, dir: string, kind: ImportKind) => string;
+  init: () => Promise<void>;
+  watcher?: FSWatcher;
+  instance?: BuildContext;
+  result?: BuildResult;
+  reBuildCount: number;
+  buildOptions: BuildOptions;
+  context: Context;
+  config: BaseBuildConfig;
+  hooks: BuilderHooks;
+  api: PluginAPI<ModuleTools>;
+  outputChunk: Map<string, Chunk>;
+  virtualModule: Map<string, string>;
+  build: (() => Promise<void>) & (() => Promise<void>);
+  emitAsset: ((name: string, chunk: AssetChunk) => void) & ((name: string, chunk: JsChunk) => void) & ((name: string, chunk: string) => void);
+  watchedFiles: Set<string>;
+  addWatchFile: (id: string) => void;
+  getTransformContext: (path: string) => ITransformContext;
+  getSourcemapContext: (path: string) => ISourcemapContext;
+  close: () => Promise<void>;
+}
+export interface ISourcemapContext {
+  addSourceMap: (pluginId: number, map?: SourceMap) => void;
+  getInlineSourceMap: () => string;
+  getSourceMap: () => SourceMap | undefined;
+  getSourceMapChain: () => SourceMap[];
+  genPluginId: (id: string) => number;
+}
+export interface ITransformContext extends ISourcemapContext {
+  addTransformResult: (pluginId: number, result: CacheValue) => void;
+  getValidCache: (pluginId: number, code: string) => undefined | CacheValue;
+}
+export type Source = {
+  code: string;
+  map?: SourceMap;
+  path: string;
+  loader?: string;
+};
+export interface CacheValue extends Source {
+  originCode: string;
+}
+export type AssetChunk = {
+  type: 'asset';
+  contents: string | Buffer;
+  entryPoint?: string;
+  /**
+   * absolute file path
+   */
+  fileName: string;
+  originalFileName?: string;
+};
+export type JsChunk = {
+  type: 'chunk';
+  contents: string;
+  entryPoint?: string;
+  /**
+   * absolute file path
+   */
+  fileName: string;
+  map?: SourceMap;
+  modules?: Record<string, any>;
+  originalFileName?: string;
+};
+export type Chunk = AssetChunk | JsChunk;
+export declare const enum ChunkType {
+  chunk = "chunk",
+  asset = "asset",
+}

package/dist/types/esbuild.js

@@ -0,0 +1,32 @@
+"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 esbuild_exports = {};
+__export(esbuild_exports, {
+  ChunkType: () => ChunkType
+});
+module.exports = __toCommonJS(esbuild_exports);
+var ChunkType;
+(function(ChunkType2) {
+  ChunkType2["chunk"] = "chunk";
+  ChunkType2["asset"] = "asset";
+})(ChunkType || (ChunkType = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChunkType
+});

package/dist/types/hooks.js

@@ -1,6 +1,16 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-//# sourceMappingURL=hooks.js.map
+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);
+var hooks_exports = {};
+module.exports = __toCommonJS(hooks_exports);

package/dist/types/index.d.ts

@@ -8,6 +8,7 @@ export * from './config';
 export * from './legacyConfig';
 export * from './dts';
 export * from './context';
+export * from './esbuild';
 export type { CliPlugin, IAppContext, PluginAPI } from '@modern-js/core';
 export type ModuleTools = {
   hooks: ModuleToolsHooks;

package/dist/types/index.js

@@ -1,13 +1,34 @@
 "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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./hooks"), module.exports);
+__reExport(types_exports, require("./command"), module.exports);
+__reExport(types_exports, require("./config"), module.exports);
+__reExport(types_exports, require("./legacyConfig"), module.exports);
+__reExport(types_exports, require("./dts"), module.exports);
+__reExport(types_exports, require("./context"), module.exports);
+__reExport(types_exports, require("./esbuild"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./hooks"),
+  ...require("./command"),
+  ...require("./config"),
+  ...require("./legacyConfig"),
+  ...require("./dts"),
+  ...require("./context"),
+  ...require("./esbuild")
 });
-const _export_star = require("@swc/helpers/_/_export_star");
-_export_star._(require("./hooks"), exports);
-_export_star._(require("./command"), exports);
-_export_star._(require("./config"), exports);
-_export_star._(require("./legacyConfig"), exports);
-_export_star._(require("./dts"), exports);
-_export_star._(require("./context"), exports);
-
-//# sourceMappingURL=index.js.map

package/dist/types/legacyConfig/index.js

@@ -1,6 +1,16 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-//# sourceMappingURL=index.js.map
+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);
+var legacyConfig_exports = {};
+module.exports = __toCommonJS(legacyConfig_exports);

package/dist/types/legacyConfig/output.d.ts

@@ -1,4 +1,4 @@
-import type { UserConfig as LibuildUserConfig } from '@modern-js/libuild';
+import { Externals, Minify, Platform } from '../config';
 export type LegacyBuildPreset = 'npm-library' | 'npm-library-with-umd' | 'npm-component' | 'npm-component-with-umd';
 export type LegacyFormat = 'esm' | 'cjs' | 'umd';
 export type LegacyTarget = 'es5' | 'es6' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'esnext';
@@ -6,10 +6,10 @@ export type LegacyBuildType = 'bundle' | 'bundleless';
 export type LegacySourceMap = boolean | 'inline' | 'external';
 export type LegacyBundleOptions = {
   entry?: Record<string, string>;
-  platform?: LibuildUserConfig['platform'];
+  platform?: Platform;
   splitting?: boolean;
-  minify?: LibuildUserConfig['minify'];
-  externals?: LibuildUserConfig['external'];
+  minify?: Minify;
+  externals?: Externals;
   skipDeps?: boolean;
   getModuleId?: (moduleName: string) => string | undefined;
 };