@modern-js/app-tools 2.3.1-alpha.2 → 2.5.0

package/dist/esm-node/utils/config.js

@@ -0,0 +1,88 @@
+import * as path from "path";
+import { bundle } from "@modern-js/node-bundle-require";
+import {
+  CONFIG_FILE_EXTENSIONS,
+  fs,
+  getServerConfig,
+  OUTPUT_CONFIG_FILE
+} from "@modern-js/utils";
+const defineServerConfig = (config) => config;
+const buildServerConfig = async ({
+  appDirectory,
+  distDirectory,
+  configFile,
+  options
+}) => {
+  const configFilePath = await getServerConfig(appDirectory, configFile);
+  const getOutputFile = async (filepath) => path.resolve(
+    distDirectory,
+    `${filepath.replace(
+      new RegExp(CONFIG_FILE_EXTENSIONS.join("|")),
+      ""
+    )}.js`
+  );
+  if (configFilePath) {
+    const configHelperFilePath = path.normalize(
+      path.join(distDirectory, "./config-helper.js")
+    );
+    const helperCode = `
+      export const defineConfig = (config) => config;
+    `;
+    await fs.ensureDir(distDirectory);
+    await fs.writeFile(configHelperFilePath, helperCode);
+    await bundle(configFilePath, {
+      ...options,
+      getOutputFile,
+      esbuildPlugins: [
+        {
+          name: "native-build-config",
+          setup(ctx) {
+            ctx.onResolve(
+              {
+                filter: /app-tools\/server/
+              },
+              () => {
+                return {
+                  path: configHelperFilePath
+                };
+              }
+            );
+          }
+        }
+      ]
+    });
+  }
+};
+const safeReplacer = () => {
+  const cache = [];
+  const keyCache = [];
+  return function(key, value) {
+    if (typeof value === "object" && value !== null) {
+      const index = cache.indexOf(value);
+      if (index !== -1) {
+        return `[Circular ${keyCache[index]}]`;
+      }
+      cache.push(value);
+      keyCache.push(key || "root");
+    }
+    return value;
+  };
+};
+const emitResolvedConfig = async (appDirectory, resolvedConfig) => {
+  var _a;
+  const outputPath = path.join(
+    appDirectory,
+    ((_a = resolvedConfig.output.distPath) == null ? void 0 : _a.root) || "./dist",
+    OUTPUT_CONFIG_FILE
+  );
+  await fs.writeJSON(outputPath, resolvedConfig, {
+    spaces: 2,
+    replacer: safeReplacer()
+  });
+};
+export {
+  buildServerConfig,
+  defineServerConfig,
+  emitResolvedConfig,
+  safeReplacer
+};

package/dist/esm-node/utils/createServer.js

@@ -0,0 +1,37 @@
+import { Server } from "@modern-js/server";
+let server = null;
+const getServer = () => server;
+const setServer = (newServer) => {
+  server = newServer;
+};
+const closeServer = async () => {
+  if (server) {
+    await server.close();
+    server = null;
+  }
+};
+const createServer = async (options) => {
+  if (server) {
+    await server.close();
+  }
+  server = new Server(options);
+  const app = await server.init();
+  return app;
+};
+const injectDataLoaderPlugin = (internalPlugins) => {
+  const DataLoaderPlugin = require.resolve("@modern-js/plugin-data-loader/server");
+  return {
+    ...internalPlugins,
+    "@modern-js/plugin-data-loader": {
+      path: DataLoaderPlugin,
+      forced: true
+    }
+  };
+};
+export {
+  closeServer,
+  createServer,
+  getServer,
+  injectDataLoaderPlugin,
+  setServer
+};

package/dist/esm-node/utils/generateWatchFiles.js

@@ -0,0 +1,33 @@
+import path from "path";
+import { fs, getServerConfig } from "@modern-js/utils";
+const getPackageConfig = (appDirectory, packageJsonConfig) => {
+  const PACKAGE_JSON_CONFIG_NAME = "modernConfig";
+  const json = JSON.parse(
+    fs.readFileSync(path.resolve(appDirectory, "./package.json"), "utf8")
+  );
+  return json[packageJsonConfig != null ? packageJsonConfig : PACKAGE_JSON_CONFIG_NAME];
+};
+const addServerConfigToDeps = async (dependencies, appDirectory, serverConfigFile) => {
+  const serverConfig = await getServerConfig(appDirectory, serverConfigFile);
+  if (serverConfig) {
+    dependencies.push(serverConfig);
+  }
+};
+async function generateWatchFiles(appContext, configDir) {
+  const { appDirectory, configFile } = appContext;
+  const configPath = path.join(appDirectory, configDir || "");
+  const dependencies = getPackageConfig(
+    appContext.appDirectory,
+    appContext.packageName
+  ) ? [path.resolve(appDirectory, "./package.json")] : [];
+  await addServerConfigToDeps(
+    dependencies,
+    appContext.appDirectory,
+    appContext.serverConfigFile
+  );
+  return [`${configPath}/html`, configFile || "./config", ...dependencies];
+}
+export {
+  addServerConfigToDeps,
+  generateWatchFiles
+};

package/dist/{js/modern → esm-node}/utils/getSelectedEntries.js

@@ -1,32 +1,12 @@
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 import { chalk, inquirer } from "@modern-js/utils";
 import { i18n, localeKeys } from "../locale";
-const getSelectedEntries = (entry, entrypoints) => __async(void 0, null, function* () {
+const getSelectedEntries = async (entry, entrypoints) => {
   const entryNames = entrypoints.map((e) => e.entryName);
   if (!entry) {
     return entryNames;
   }
   if (typeof entry === "boolean") {
-    const { selected } = yield inquirer.prompt([
+    const { selected } = await inquirer.prompt([
       {
         type: "checkbox",
         name: "selected",
@@ -52,7 +32,7 @@ const getSelectedEntries = (entry, entrypoints) => __async(void 0, null, functio
     }
   });
   return entry;
-});
+};
 export {
   getSelectedEntries
 };

package/dist/esm-node/utils/getServerInternalPlugins.js

@@ -0,0 +1,18 @@
+async function getServerInternalPlugins(api) {
+  const hookRunners = api.useHookRunners();
+  const { plugins: serverPlugins } = await hookRunners.collectServerPlugins({
+    plugins: []
+  });
+  const serverInternalPlugins = serverPlugins.reduce(
+    (result, plugin) => Object.assign(result, plugin),
+    {}
+  );
+  api.setAppContext({
+    ...api.useAppContext(),
+    serverInternalPlugins
+  });
+  return serverInternalPlugins;
+}
+export {
+  getServerInternalPlugins
+};

package/dist/esm-node/utils/printInstructions.js

@@ -0,0 +1,11 @@
+import { prettyInstructions, logger } from "@modern-js/utils";
+const printInstructions = async (hookRunners, appContext, config) => {
+  const message = prettyInstructions(appContext, config);
+  const { instructions } = await hookRunners.beforePrintInstructions({
+    instructions: message
+  });
+  logger.info(instructions);
+};
+export {
+  printInstructions
+};

package/dist/esm-node/utils/restart.js

@@ -0,0 +1,22 @@
+import { cli } from "@modern-js/core";
+import { chalk, clearConsole, logger, program } from "@modern-js/utils";
+async function restart(hooksRunner, filename) {
+  clearConsole();
+  logger.info(`Restart because ${chalk.yellow(filename)} is changed...
+`);
+  let hasGetError = false;
+  await hooksRunner.beforeRestart();
+  try {
+    await cli.init(cli.getPrevInitOptions());
+  } catch (err) {
+    console.error(err);
+    hasGetError = true;
+  } finally {
+    if (!hasGetError) {
+      program.parse(process.argv);
+    }
+  }
+}
+export {
+  restart
+};

package/dist/esm-node/utils/routes.js

@@ -0,0 +1,10 @@
+import path from "path";
+import { fs, ROUTE_SPEC_FILE } from "@modern-js/utils";
+const generateRoutes = async (appContext) => {
+  const { serverRoutes, distDirectory } = appContext;
+  const output = JSON.stringify({ routes: serverRoutes }, null, 2);
+  await fs.outputFile(path.join(distDirectory, ROUTE_SPEC_FILE), output);
+};
+export {
+  generateRoutes
+};

package/dist/types/analyze/generateCode.d.ts

@@ -2,4 +2,4 @@ import { IAppContext, PluginAPI } from '@modern-js/core';
 import type { Entrypoint } from '@modern-js/types';
 import { AppNormalizedConfig, AppTools, ImportStatement } from '../types';
 export declare const createImportStatements: (statements: ImportStatement[]) => string;
-export declare const generateCode: (appContext: IAppContext, config: AppNormalizedConfig, entrypoints: Entrypoint[], api: PluginAPI<AppTools>) => Promise<void>;
+export declare const generateCode: (appContext: IAppContext, config: AppNormalizedConfig<'shared'>, entrypoints: Entrypoint[], api: PluginAPI<AppTools<'shared'>>) => Promise<void>;

package/dist/types/analyze/getBundleEntry.d.ts

@@ -1,3 +1,3 @@
 import type { Entrypoint } from '@modern-js/types';
 import type { AppNormalizedConfig, IAppContext } from '../types';
-export declare const getBundleEntry: (appContext: IAppContext, config: AppNormalizedConfig) => Entrypoint[];
+export declare const getBundleEntry: (appContext: IAppContext, config: AppNormalizedConfig<'shared'>) => Entrypoint[];

package/dist/types/analyze/getFileSystemEntry.d.ts

@@ -1,4 +1,4 @@
 import type { Entrypoint } from '@modern-js/types';
 import type { AppNormalizedConfig, IAppContext } from '../types';
 export type { Entrypoint };
-export declare const getFileSystemEntry: (appContext: IAppContext, config: AppNormalizedConfig) => Entrypoint[];
+export declare const getFileSystemEntry: (appContext: IAppContext, config: AppNormalizedConfig<'shared'>) => Entrypoint[];

package/dist/types/analyze/getHtmlTemplate.d.ts

@@ -1,9 +1,9 @@
 import type { Entrypoint, HtmlTemplates } from '@modern-js/types';
 import type { AppNormalizedConfig, AppTools, IAppContext, PluginAPI } from '../types';
-export declare const getHtmlTemplate: (entrypoints: Entrypoint[], api: PluginAPI<AppTools>, {
+export declare const getHtmlTemplate: (entrypoints: Entrypoint[], api: PluginAPI<AppTools<'shared'>>, {
   appContext,
   config
 }: {
   appContext: IAppContext;
-  config: AppNormalizedConfig;
+  config: AppNormalizedConfig<'shared'>;
 }) => Promise<HtmlTemplates>;

package/dist/types/analyze/getServerRoutes.d.ts

@@ -6,5 +6,5 @@ export declare const getServerRoutes: (entrypoints: Entrypoint[], {
   config
 }: {
   appContext: IAppContext;
-  config: AppNormalizedConfig;
+  config: AppNormalizedConfig<'shared'>;
 }) => ServerRoute[];

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

@@ -1,6 +1,10 @@
 import type { CliPlugin } from '@modern-js/core';
 import { AppTools } from '../types';
 
-declare const _default: () => CliPlugin<AppTools>;
+declare const _default: ({
+  bundler
+}: {
+  bundler: 'webpack' | 'rspack';
+}) => CliPlugin<AppTools<'shared'>>;
 
 export default _default;

package/dist/types/builder/builder-rspack/index.d.ts

@@ -0,0 +1,2 @@
+import { BuilderOptions } from '../shared';
+export declare function createRspackBuilderForModern(options: BuilderOptions<'rspack'>): Promise<import("@modern-js/builder-shared").BuilderInstance<import("@modern-js/builder-shared").BuilderProvider<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>>;

package/dist/types/builder/{builderPlugins → builder-webpack/builderPlugins}/compatModern.d.ts

@@ -1,6 +1,6 @@
 import { BuilderPlugin } from '@modern-js/builder-shared';
 import type { BuilderPluginAPI } from '@modern-js/builder-webpack-provider';
-import type { IAppContext, AppNormalizedConfig } from '../../types';
+import { BuilderOptions } from '../../shared';
 type Parameter<T extends (arg: any) => void> = Parameters<T>[0];
 type FnParameter<T extends {
   [p: string]: (arg: any) => void;
@@ -10,5 +10,5 @@ export type PluginCompatModernOptions = FnParameter<Partial<Pick<BuilderPluginAP
  * Provides default configuration consistent with modern.js v1
  */
 
-export declare const PluginCompatModern: (appContext: IAppContext, modernConfig: AppNormalizedConfig, options?: PluginCompatModernOptions) => BuilderPlugin<BuilderPluginAPI>;
+export declare const PluginCompatModern: (options: BuilderOptions<'webpack'>) => BuilderPlugin<BuilderPluginAPI>;
 export {};

package/dist/types/builder/builder-webpack/index.d.ts

@@ -0,0 +1,4 @@
+import { BuilderInstance } from '@modern-js/builder';
+import { BuilderWebpackProvider } from '@modern-js/builder-webpack-provider';
+import { BuilderOptions } from '../shared';
+export declare function createWebpackBuilderForModern(options: BuilderOptions<'webpack'>): Promise<BuilderInstance<BuilderWebpackProvider>>;

package/dist/types/builder/{webpackPlugins/routerPlugin.d.ts → builder-webpack/webpackPlugins/RouterPlugin.d.ts}

@@ -1,4 +1,4 @@
 import type { Compiler } from 'webpack';
-export default class RouterPlugin {
+export declare class RouterPlugin {
   apply(compiler: Compiler): void;
 }

package/dist/types/builder/builder-webpack/webpackPlugins/index.d.ts

@@ -0,0 +1 @@
+export * from './RouterPlugin';

package/dist/types/builder/generator/createBuilderOptions.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderTarget, CreateBuilderOptions } from '@modern-js/builder-shared';
+import type { IAppContext } from '@modern-js/core';
+export declare function createBuilderOptions(target: BuilderTarget | BuilderTarget[], appContext: IAppContext): CreateBuilderOptions;

package/dist/types/builder/generator/createBuilderProviderConfig.d.ts

@@ -0,0 +1,2 @@
+import type { AppNormalizedConfig, Bundler, IAppContext } from '../../types';
+export declare function createBuilderProviderConfig<B extends Bundler>(resolveConfig: AppNormalizedConfig<B>, appContext: IAppContext, modifyBuilderConfig?: (config: AppNormalizedConfig<B>) => void): AppNormalizedConfig<B>;

package/dist/types/builder/generator/getBuilderTargets.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderTarget } from '@modern-js/builder-shared';
+import type { AppNormalizedConfig } from '../../types';
+export declare function getBuilderTargets(normalizedConfig: AppNormalizedConfig<'shared'>): BuilderTarget[];

package/dist/types/builder/generator/index.d.ts

@@ -0,0 +1,17 @@
+import type { BuilderProvider, BuilderInstance } from '@modern-js/builder-shared';
+import { BuilderOptions, ModifyBuilderConfig, ModifyBuilderInstance } from '../shared';
+import { Bundler } from '../../types';
+export type GenerateProvider = (c: {
+  builderConfig: any;
+}) => BuilderProvider;
+/**
+ * @param options BuilderOptions
+ * @param generateProvider GenerateProvider
+ * @param utils - ModifyBuilderConfig, ModifyBuilderInstance
+ * @returns BuilderInstance
+ */
+
+export declare function generateBuilder<B extends Bundler>(options: BuilderOptions<B>, generateProvider: GenerateProvider, utils?: {
+  modifyBuilderConfig?: ModifyBuilderConfig<B>;
+  modifyBuilderInstance?: ModifyBuilderInstance;
+}): Promise<BuilderInstance<BuilderProvider<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>>;

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

@@ -1,18 +1 @@
-import { BuilderInstance, BuilderTarget, CreateBuilderOptions } from '@modern-js/builder';
-import { BuilderConfig, BuilderWebpackProvider } from '@modern-js/builder-webpack-provider';
-import type { IAppContext } from '@modern-js/core';
-import type { AppNormalizedConfig } from '../types';
-import { PluginCompatModernOptions } from './builderPlugins/compatModern';
-export type BuilderOptions = {
-  target?: BuilderTarget | BuilderTarget[];
-  normalizedConfig: AppNormalizedConfig;
-  appContext: IAppContext;
-  compatPluginConfig?: PluginCompatModernOptions;
-};
-export declare function createBuilderForModern({
-  normalizedConfig,
-  appContext,
-  compatPluginConfig
-}: BuilderOptions): Promise<BuilderInstance<BuilderWebpackProvider>>;
-export declare function createBuilderProviderConfig(normalizedConfig: AppNormalizedConfig, appContext: IAppContext): BuilderConfig;
-export declare function createBuilderOptions(target: BuilderTarget | BuilderTarget[], appContext: IAppContext): CreateBuilderOptions;
+export declare function createBuilderGenerator(bundler: 'webpack' | 'rspack'): Promise<typeof import("./builder-rspack").createRspackBuilderForModern | typeof import("./builder-webpack").createWebpackBuilderForModern>;

package/dist/types/builder/shared/builderPlugins/adapterModern.d.ts

@@ -0,0 +1,13 @@
+import { BuilderPlugin, DefaultBuilderPluginAPI } from '@modern-js/builder-shared';
+import { BuilderConfig as RspackBuilderConfig, NormalizedConfig as RspackNormalizedConfig } from '@modern-js/builder-rspack-provider';
+import { BuilderConfig as WebpackBuilderConfig, NormalizedConfig as WebpackNormalizedConfig } from '@modern-js/builder-webpack-provider';
+import type { BuilderOptions } from '../types';
+import type { Bundler } from '../../../types';
+type BuilderConfig = RspackBuilderConfig | WebpackBuilderConfig;
+type NormalizedConfig = RspackNormalizedConfig | WebpackNormalizedConfig;
+type BuilderPluginAPI = DefaultBuilderPluginAPI<BuilderConfig, NormalizedConfig>;
+export declare const builderPluginAdapterModern: <B extends Bundler>(options: BuilderOptions<B>) => BuilderPlugin<BuilderPluginAPI>;
+/** register builder hooks callback */
+
+export declare function applyCallbacks<B extends Bundler>(api: BuilderPluginAPI, options: BuilderOptions<B>): void;
+export {};

package/dist/types/builder/{webpackPlugins/htmlAsyncChunkPlugin.d.ts → shared/bundlerPlugins/HtmlAsyncChunkPlugin.d.ts}

@@ -1,8 +1,9 @@
 import type { webpack } from '@modern-js/builder-webpack-provider';
+import type { Rspack } from '@modern-js/builder-rspack-provider';
 import type HtmlWebpackPlugin from '@modern-js/builder-webpack-provider/html-webpack-plugin';
 export declare class HtmlAsyncChunkPlugin {
   name: string;
   htmlWebpackPlugin: typeof HtmlWebpackPlugin;
   constructor(htmlWebpackPlugin: typeof HtmlWebpackPlugin);
-  apply(compiler: webpack.Compiler): void;
+  apply(compiler: webpack.Compiler | Rspack.Compiler): void;
 }

package/dist/types/builder/{webpackPlugins/htmlBottomTemplate.d.ts → shared/bundlerPlugins/HtmlBottomTemplate.d.ts}

@@ -1,4 +1,5 @@
 import type { webpack } from '@modern-js/builder-webpack-provider';
+import type { Rspack } from '@modern-js/builder-rspack-provider';
 import type HtmlWebpackPlugin from '@modern-js/builder-webpack-provider/html-webpack-plugin';
 export declare class BottomTemplatePlugin {
   htmlWebpackPlugin: typeof HtmlWebpackPlugin;
@@ -6,5 +7,5 @@ export declare class BottomTemplatePlugin {
   bodyRegExp: RegExp;
   name: string;
   constructor(htmlWebpackPlugin: typeof HtmlWebpackPlugin);
-  apply(compiler: webpack.Compiler): void;
+  apply(compiler: Rspack.Compiler | webpack.Compiler): void;
 }

package/dist/types/builder/{share.d.ts → shared/createCopyPattern.d.ts}

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { WebpackChain } from '@modern-js/builder-webpack-provider';
-import { AppNormalizedConfig, IAppContext } from '../types';
+import { AppNormalizedConfig, IAppContext } from '../../types';
 export declare function createCopyPattern(appContext: IAppContext, config: AppNormalizedConfig, patternsType: 'upload' | 'public', chain?: WebpackChain): {
   info: (file: {
     sourceFilename: string;

package/dist/types/builder/shared/index.d.ts

@@ -0,0 +1,3 @@
+export * from './createCopyPattern';
+export * from './types';
+export * from './builderPlugins/adapterModern';

package/dist/types/builder/shared/loaders/serverModuleLoader.d.ts

@@ -0,0 +1,4 @@
+import type { webpack } from '@modern-js/builder-webpack-provider';
+import type { Rspack } from '@modern-js/builder-rspack-provider';
+declare function loader(this: webpack.LoaderContext<void> | Rspack.LoaderContext): string;
+export default loader;

package/dist/types/builder/shared/types.d.ts

@@ -0,0 +1,16 @@
+import type { BuilderPluginAPI as WebpackBuilderPluginAPI } from '@modern-js/builder-webpack-provider';
+import type { BuilderPluginAPI as RspackBuilderPluginAPI } from '@modern-js/builder-rspack-provider';
+import { BuilderInstance } from '@modern-js/builder-shared';
+import { AppNormalizedConfig, Bundler, IAppContext } from '../../types';
+type Parameter<T extends (arg: any) => void> = Parameters<T>[0];
+type FnParameter<T extends {
+  [p: string]: (arg: any) => void;
+}> = { [P in keyof T]: Parameter<T[P]> };
+type BuilderPluginCallbacks<B extends Bundler> = FnParameter<Partial<Pick<B extends 'rspack' ? RspackBuilderPluginAPI : WebpackBuilderPluginAPI, 'onAfterBuild' | 'onAfterCreateCompiler' | 'onAfterStartDevServer' | 'onBeforeBuild' | 'onBeforeCreateCompiler' | 'onBeforeStartDevServer' | 'onDevCompileDone' | 'onExit'>>>;
+export type BuilderOptions<B extends Bundler> = {
+  normalizedConfig: AppNormalizedConfig<B>;
+  appContext: IAppContext;
+} & BuilderPluginCallbacks<B>;
+export type ModifyBuilderConfig<B extends Bundler> = (config: AppNormalizedConfig<B>) => Promise<void> | void;
+export type ModifyBuilderInstance = (builder: BuilderInstance) => Promise<void> | void;
+export {};

package/dist/types/commands/build.d.ts

@@ -1,4 +1,4 @@
 import { PluginAPI } from '@modern-js/core';
 import type { BuildOptions } from '../utils/types';
 import type { AppTools } from '../types';
-export declare const build: (api: PluginAPI<AppTools>, options?: BuildOptions) => Promise<void>;
+export declare const build: (api: PluginAPI<AppTools<'shared'>>, options?: BuildOptions) => Promise<void>;

package/dist/types/commands/deploy.d.ts

@@ -1,3 +1,3 @@
 import type { PluginAPI } from '@modern-js/core';
 import type { AppTools } from '../types';
-export declare const deploy: (api: PluginAPI<AppTools>, options: any) => Promise<void>;
+export declare const deploy: (api: PluginAPI<AppTools<'shared'>>, options: any) => Promise<void>;

package/dist/types/commands/dev.d.ts

@@ -1,4 +1,4 @@
 import { PluginAPI } from '@modern-js/core';
 import { DevOptions } from '../utils/types';
 import type { AppTools } from '../types';
-export declare const dev: (api: PluginAPI<AppTools>, options: DevOptions) => Promise<void>;
+export declare const dev: (api: PluginAPI<AppTools<'shared'>>, options: DevOptions) => Promise<void>;

package/dist/types/commands/inspect.d.ts

@@ -1,7 +1,7 @@
 import type { PluginAPI } from '@modern-js/core';
 import type { InspectOptions } from '../utils/types';
 import type { AppTools } from '../types';
-export declare const inspect: (api: PluginAPI<AppTools>, options: InspectOptions) => Promise<{
+export declare const inspect: (api: PluginAPI<AppTools<'shared'>>, options: InspectOptions) => Promise<{
   builderConfig: string;
   bundlerConfigs: string[];
   origin: {

package/dist/types/commands/serve.d.ts

@@ -1,3 +1,3 @@
 import type { PluginAPI } from '@modern-js/core';
 import type { AppTools } from '../types';
-export declare const start: (api: PluginAPI<AppTools>) => Promise<void>;
+export declare const start: (api: PluginAPI<AppTools<'shared'>>) => Promise<void>;

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

@@ -1,3 +1,3 @@
 import { IAppContext, AppUserConfig, AppLegacyUserConfig } from '../types';
-export declare function createDefaultConfig(appContext: IAppContext): AppUserConfig;
+export declare function createDefaultConfig(appContext: IAppContext, bundler: 'webpack' | 'rspack'): AppUserConfig<'webpack'> | AppUserConfig<'rspack'>;
 export declare function createLegacyDefaultConfig(appContext: IAppContext): AppLegacyUserConfig;

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

@@ -1,2 +1,3 @@
-export { createDefaultConfig, createLegacyDefaultConfig } from './default';
-export { initialNormalizedConfig, checkIsLegacyConfig } from './initial';
+export * from './legacy';
+export * from './initialize';
+export * from './default';

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

@@ -0,0 +1,2 @@
+import type { AppNormalizedConfig, IAppContext } from '../../types';
+export declare function initialNormalizedConfig(config: AppNormalizedConfig<'shared'>, appContext: IAppContext, bundler: 'webpack' | 'rspack'): AppNormalizedConfig<'shared'>;

package/dist/types/config/{initial → initialize}/inits.d.ts

@@ -1,4 +1,4 @@
 import { AppNormalizedConfig, IAppContext } from '../../types';
-export declare function initHtmlConfig(config: AppNormalizedConfig, appContext: IAppContext): import("@modern-js/builder-shared").SharedHtmlConfig;
-export declare function initSourceConfig(config: AppNormalizedConfig, appContext: IAppContext): void;
-export declare function initToolsConfig(config: AppNormalizedConfig): void;
+export declare function initHtmlConfig(config: AppNormalizedConfig<'shared'>, appContext: IAppContext): import("@modern-js/builder-shared").SharedHtmlConfig;
+export declare function initSourceConfig(config: AppNormalizedConfig<'shared'>, appContext: IAppContext, bundler: 'webpack' | 'rspack'): void;
+export declare function initToolsConfig(config: AppNormalizedConfig<'webpack'>): void;

package/dist/types/config/{initial → legacy}/createHtmlConfig.d.ts

@@ -1,2 +1,2 @@
 import { AppLegacyNormalizedConfig, AppNormalizedConfig } from '../../types';
-export declare function createHtmlConfig(config: Readonly<AppLegacyNormalizedConfig>): AppNormalizedConfig['html'];
+export declare function createHtmlConfig(config: Readonly<AppLegacyNormalizedConfig>): AppNormalizedConfig<'webpack'>['html'];

package/dist/types/config/{initial → legacy}/createOutputConfig.d.ts

@@ -1,2 +1,2 @@
 import { AppLegacyNormalizedConfig, AppNormalizedConfig } from '../../types';
-export declare function createOutputConfig(config: Readonly<AppLegacyNormalizedConfig>): AppNormalizedConfig['output'];
+export declare function createOutputConfig(config: Readonly<AppLegacyNormalizedConfig>): AppNormalizedConfig<'webpack'>['output'];

package/dist/types/config/{initial → legacy}/createSourceConfig.d.ts

@@ -1,2 +1,2 @@
 import { AppLegacyNormalizedConfig, AppNormalizedConfig } from '../../types';
-export declare function createSourceConfig(config: AppLegacyNormalizedConfig): AppNormalizedConfig['source'];
+export declare function createSourceConfig(config: AppLegacyNormalizedConfig): AppNormalizedConfig<'webpack'>['source'];

package/dist/types/config/{initial → legacy}/createToolsConfig.d.ts

@@ -1,2 +1,2 @@
 import { AppLegacyNormalizedConfig, AppNormalizedConfig } from '../../types';
-export declare function createToolsConfig(config: AppLegacyNormalizedConfig): AppNormalizedConfig['tools'];
+export declare function createToolsConfig(config: AppLegacyNormalizedConfig): AppNormalizedConfig<'webpack'>['tools'];

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

@@ -0,0 +1,3 @@
+import type { AppLegacyNormalizedConfig, AppLegacyUserConfig, AppNormalizedConfig, AppUserConfig } from '../../types';
+export declare function transformNormalizedConfig(config: AppLegacyNormalizedConfig): AppNormalizedConfig<'webpack'>;
+export declare function checkIsLegacyConfig(config: AppLegacyUserConfig | AppUserConfig): config is AppLegacyUserConfig;

package/dist/types/defineConfig.d.ts

@@ -1,6 +1,6 @@
 import type { UserConfigExport } from '@modern-js/core';
-import type { AppUserConfig, AppLegacyUserConfig } from './types';
-export declare const defineConfig: (config: UserConfigExport<AppUserConfig>) => UserConfigExport<AppUserConfig>;
+import type { AppLegacyUserConfig, AppUserConfig } from './types';
+export declare const defineConfig: <B extends "webpack" | "rspack" = "webpack">(config: UserConfigExport<AppUserConfig<B>>) => UserConfigExport<AppUserConfig<B>>;
 /**
  * @deprecated
  * Using defineConfig first.