@modern-js/app-tools 2.63.1 → 2.63.2

package/dist/esm-node/index.js

@@ -1,5 +1,143 @@
-import { appTools } from "./new/index";
-import { initAppContext } from "./new/index";
+import { getLocaleLanguage } from "@modern-js/plugin-i18n/language-detector";
+import { createAsyncHook, createCollectAsyncHook } from "@modern-js/plugin-v2";
+import { castArray } from "@modern-js/uni-builder";
+import { cleanRequireCache, deprecatedCommands, emptyDir, getArgv, getCommand } from "@modern-js/utils";
+import { buildCommand, deployCommand, devCommand, inspectCommand, newCommand, serverCommand, upgradeCommand } from "./commands";
+import { compatPlugin } from "./compat";
+import { DEFAULT_RUNTIME_CONFIG_FILE, DEFAULT_SERVER_CONFIG_FILE } from "./constants";
+import { i18n } from "./locale";
+import analyzePlugin from "./plugins/analyze";
+import deployPlugin from "./plugins/deploy";
+import initializePlugin from "./plugins/initialize";
+import serverBuildPlugin from "./plugins/serverBuild";
+import { generateWatchFiles } from "./utils/generateWatchFiles";
+import { initAppContext } from "./utils/initAppContext";
+import { restart } from "./utils/restart";
+export * from "./defineConfig";
+const appTools = (options = {
+  // default webpack to be compatible with original projects
+  bundler: "webpack"
+}) => ({
+  name: "@modern-js/app-tools",
+  usePlugins: [
+    compatPlugin(),
+    initializePlugin({
+      bundler: (options === null || options === void 0 ? void 0 : options.bundler) && [
+        "rspack",
+        "experimental-rspack"
+      ].includes(options.bundler) ? "rspack" : "webpack"
+    }),
+    analyzePlugin({
+      bundler: (options === null || options === void 0 ? void 0 : options.bundler) && [
+        "rspack",
+        "experimental-rspack"
+      ].includes(options.bundler) ? "rspack" : "webpack"
+    }),
+    serverBuildPlugin(),
+    deployPlugin()
+  ],
+  post: [
+    "@modern-js/plugin-initialize",
+    "@modern-js/plugin-analyze",
+    "@modern-js/plugin-ssr",
+    "@modern-js/plugin-document",
+    "@modern-js/plugin-state",
+    "@modern-js/plugin-router",
+    "@modern-js/plugin-router-v5",
+    "@modern-js/plugin-polyfill"
+  ],
+  registryHooks: {
+    onBeforeConfig: createAsyncHook(),
+    onAfterPrepare: createAsyncHook(),
+    deploy: createAsyncHook(),
+    _internalRuntimePlugins: createAsyncHook(),
+    _internalServerPlugins: createAsyncHook(),
+    checkEntryPoint: createAsyncHook(),
+    modifyEntrypoints: createAsyncHook(),
+    modifyFileSystemRoutes: createAsyncHook(),
+    modifyServerRoutes: createAsyncHook(),
+    generateEntryCode: createAsyncHook(),
+    onBeforeGenerateRoutes: createAsyncHook(),
+    onBeforePrintInstructions: createAsyncHook(),
+    registerDev: createCollectAsyncHook(),
+    registerBuildPlatform: createCollectAsyncHook(),
+    addRuntimeExports: createAsyncHook()
+  },
+  setup: (api) => {
+    var _userConfig_output;
+    const context = api.getAppContext();
+    const userConfig = api.getConfig();
+    const locale = getLocaleLanguage();
+    i18n.changeLanguage({
+      locale
+    });
+    api.updateAppContext(initAppContext({
+      appDirectory: context.appDirectory,
+      options: {},
+      serverConfigFile: DEFAULT_SERVER_CONFIG_FILE,
+      runtimeConfigFile: DEFAULT_RUNTIME_CONFIG_FILE,
+      tempDir: (_userConfig_output = userConfig.output) === null || _userConfig_output === void 0 ? void 0 : _userConfig_output.tempDir
+    }));
+    api.addCommand(async ({ program }) => {
+      await devCommand(program, api);
+      await buildCommand(program, api);
+      serverCommand(program, api);
+      deployCommand(program, api);
+      newCommand(program, locale);
+      inspectCommand(program, api);
+      upgradeCommand(program);
+      deprecatedCommands(program);
+    });
+    api.onPrepare(async () => {
+      const command = getCommand();
+      if (command === "deploy") {
+        const isSkipBuild = [
+          "-s",
+          "--skip-build"
+        ].some((tag) => {
+          return getArgv().includes(tag);
+        });
+        if (isSkipBuild) {
+          return;
+        }
+      }
+      if (command === "dev" || command === "start" || command === "build" || command === "deploy") {
+        const resolvedConfig = api.getNormalizedConfig();
+        if (resolvedConfig.output.cleanDistPath) {
+          const appContext = api.getAppContext();
+          await emptyDir(appContext.distDirectory);
+        }
+      }
+    });
+    api.addWatchFiles(async () => {
+      const appContext = api.getAppContext();
+      const config = api.getNormalizedConfig();
+      const files = await generateWatchFiles(appContext, config.source.configDir);
+      const watchFiles = castArray(config.dev.watchFiles);
+      watchFiles.forEach(({ type, paths }) => {
+        if (type === "reload-server") {
+          files.push(...Array.isArray(paths) ? paths : [
+            paths
+          ]);
+        }
+      });
+      return files;
+    });
+    api.onFileChanged(async (e) => {
+      const { filename, eventType, isPrivate } = e;
+      if (!isPrivate && (eventType === "change" || eventType === "unlink")) {
+        const { closeServer } = await import("./utils/createServer.js");
+        await closeServer();
+        await restart(api.getHooks(), filename);
+      }
+    });
+    api.onBeforeRestart(() => {
+      cleanRequireCache([
+        require.resolve("./plugins/analyze")
+      ]);
+    });
+  }
+});
 import { defineConfig, defineLegacyConfig } from "./defineConfig";
 import { mergeConfig } from "@modern-js/core";
 import { dev } from "./commands/dev";

package/dist/esm-node/plugins/analyze/getServerRoutes.js

@@ -1,6 +1,5 @@
-import fs from "fs";
 import path from "path";
-import { SERVER_BUNDLE_DIRECTORY, SERVER_WORKER_BUNDLE_DIRECTORY, getEntryOptions, isPlainObject, removeLeadingSlash, removeTailSlash, urlJoin } from "@modern-js/utils";
+import { fs, ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, SERVER_WORKER_BUNDLE_DIRECTORY, getEntryOptions, isPlainObject, removeLeadingSlash, removeTailSlash, urlJoin } from "@modern-js/utils";
 import { isMainEntry } from "../../utils/routes";
 import { walkDirectory } from "./utils";
 const applyBaseUrl = (baseUrl, routes) => {
@@ -130,6 +129,16 @@ const getServerRoutes = (entrypoints, { appContext, config }) => [
   ...collectStaticRoutes(appContext, config)
 ];
 const toPosix = (pathStr) => pathStr.split(path.sep).join(path.posix.sep);
+const getProdServerRoutes = (distDirectory) => {
+  const routeJSON = path.join(distDirectory, ROUTE_SPEC_FILE);
+  try {
+    const { routes } = fs.readJSONSync(routeJSON);
+    return routes;
+  } catch (e) {
+    throw new Error(`Failed to read routes from ${routeJSON}, please check if the file exists.`);
+  }
+};
 export {
+  getProdServerRoutes,
   getServerRoutes
 };

package/dist/esm-node/plugins/analyze/index.js

@@ -6,7 +6,7 @@ import { emitResolvedConfig } from "../../utils/config";
 import { getSelectedEntries } from "../../utils/getSelectedEntries";
 import { printInstructions } from "../../utils/printInstructions";
 import { generateRoutes } from "../../utils/routes";
-import { checkIsBuildCommands } from "./utils";
+import { checkIsBuildCommands, checkIsServeCommand } from "./utils";
 const debug = createDebugger("plugin-analyze");
 var analyze_default = ({ bundler }) => ({
   name: "@modern-js/plugin-analyze",
@@ -29,10 +29,19 @@ var analyze_default = ({ bundler }) => ({
       }
       const apiOnly = await isApiOnly(appContext.appDirectory, (_resolvedConfig_source = resolvedConfig.source) === null || _resolvedConfig_source === void 0 ? void 0 : _resolvedConfig_source.entriesDir, appContext.apiDirectory);
       await hooks.addRuntimeExports.call();
+      const [{ getProdServerRoutes }] = await Promise.all([
+        import("./getServerRoutes.js")
+      ]);
       if (apiOnly) {
-        const { routes: routes2 } = await hooks.modifyServerRoutes.call({
-          routes: []
-        });
+        const routes2 = [];
+        if (checkIsServeCommand()) {
+          routes2.push(...getProdServerRoutes(appContext.distDirectory));
+        } else {
+          const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
+            routes: []
+          });
+          routes2.push(...modifiedRoutes);
+        }
         debug(`server routes: %o`, routes2);
         api.updateAppContext({
           apiOnly,
@@ -49,13 +58,19 @@ var analyze_default = ({ bundler }) => ({
         entrypoints: await getBundleEntry(hooks, appContext, resolvedConfig)
       });
       debug(`entrypoints: %o`, entrypoints);
-      const initialRoutes = getServerRoutes(entrypoints, {
-        appContext,
-        config: resolvedConfig
-      });
-      const { routes } = await hooks.modifyServerRoutes.call({
-        routes: initialRoutes
-      });
+      const routes = [];
+      if (checkIsServeCommand()) {
+        routes.push(...getProdServerRoutes(appContext.distDirectory));
+      } else {
+        const initialRoutes = getServerRoutes(entrypoints, {
+          appContext,
+          config: resolvedConfig
+        });
+        const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
+          routes: initialRoutes
+        });
+        routes.push(...modifiedRoutes);
+      }
       debug(`server routes: %o`, routes);
       appContext = {
         ...api.getAppContext(),

package/dist/esm-node/plugins/analyze/utils.js

@@ -50,6 +50,10 @@ const checkIsBuildCommands = () => {
   const command = getCommand();
   return buildCommands.includes(command);
 };
+const checkIsServeCommand = () => {
+  const command = getCommand();
+  return command === "serve";
+};
 const isSubDirOrEqual = (parent, child) => {
   if (parent === child) {
     return true;
@@ -60,6 +64,7 @@ const isSubDirOrEqual = (parent, child) => {
 };
 export {
   checkIsBuildCommands,
+  checkIsServeCommand,
   getServerCombinedModueFile,
   isSubDirOrEqual,
   parseModule,

package/dist/esm-node/plugins/serverBuild.js

@@ -17,40 +17,38 @@ function checkHasConfig(appDir, metaName = "modern-js") {
 var serverBuild_default = () => ({
   name: "@modern-js/server-build",
   setup(api) {
-    return {
-      async afterBuild() {
-        const { appDirectory, distDirectory, metaName } = api.useAppContext();
-        if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) {
-          return;
-        }
-        const modernConfig = api.useResolvedConfigContext();
-        const distDir = path.resolve(distDirectory);
-        const serverDir = path.resolve(appDirectory, SERVER_DIR);
-        const sharedDir = path.resolve(appDirectory, SHARED_DIR);
-        const tsconfigPath = path.resolve(appDirectory, TS_CONFIG_FILENAME);
-        const sourceDirs = [];
-        if (fs.existsSync(serverDir)) {
-          sourceDirs.push(serverDir);
-          if (fs.existsSync(sharedDir)) {
-            sourceDirs.push(sharedDir);
-          }
-        }
-        const { server } = modernConfig;
-        const { alias } = modernConfig.source;
-        const { babel } = modernConfig.tools;
-        if (sourceDirs.length > 0) {
-          await compile(appDirectory, {
-            server,
-            alias,
-            babelConfig: babel
-          }, {
-            sourceDirs,
-            distDir,
-            tsconfigPath
-          });
+    api.onAfterBuild(async () => {
+      const { appDirectory, distDirectory, metaName } = api.getAppContext();
+      if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) {
+        return;
+      }
+      const modernConfig = api.getNormalizedConfig();
+      const distDir = path.resolve(distDirectory);
+      const serverDir = path.resolve(appDirectory, SERVER_DIR);
+      const sharedDir = path.resolve(appDirectory, SHARED_DIR);
+      const tsconfigPath = path.resolve(appDirectory, TS_CONFIG_FILENAME);
+      const sourceDirs = [];
+      if (fs.existsSync(serverDir)) {
+        sourceDirs.push(serverDir);
+        if (fs.existsSync(sharedDir)) {
+          sourceDirs.push(sharedDir);
         }
       }
-    };
+      const { server } = modernConfig;
+      const { alias } = modernConfig.source;
+      const { babel } = modernConfig.tools;
+      if (sourceDirs.length > 0) {
+        await compile(appDirectory, {
+          server,
+          alias,
+          babelConfig: babel
+        }, {
+          sourceDirs,
+          distDir,
+          tsconfigPath
+        });
+      }
+    });
   }
 });
 export {

package/dist/esm-node/{new/run.js → run/index.js}

@@ -1,11 +1,11 @@
 import { initAppDir } from "@modern-js/plugin-v2/cli";
 import { run as CLIPluginRun } from "@modern-js/plugin-v2/run";
 import { minimist } from "@modern-js/utils";
-import { handleSetupResult } from "./compat/hooks";
-import { PACKAGE_JSON_CONFIG_NAME } from "./constants";
-import { getConfigFile } from "./getConfigFile";
-import { loadInternalPlugins } from "./loadPlugins";
-import { getIsAutoLoadPlugins } from "./utils";
+import { handleSetupResult } from "../compat/hooks";
+import { PACKAGE_JSON_CONFIG_NAME } from "../constants";
+import { getConfigFile } from "../utils/getConfigFile";
+import { isAutoLoadPlugins } from "../utils/isAutoLoadPlugins";
+import { loadInternalPlugins } from "../utils/loadPlugins";
 async function run({ cwd, initialLog, version, internalPlugins, packageJsonConfig, configFile }) {
   const command = process.argv[2];
   const cliParams = minimist(process.argv.slice(2));
@@ -27,7 +27,7 @@ async function run({ cwd, initialLog, version, internalPlugins, packageJsonConfi
   }
   const appDirectory = await initAppDir(cwd);
   const finalConfigFile = customConfigFile || getConfigFile(configFile);
-  const autoLoadPlugins = await getIsAutoLoadPlugins(appDirectory, finalConfigFile);
+  const autoLoadPlugins = await isAutoLoadPlugins(appDirectory, finalConfigFile);
   const plugins = await loadInternalPlugins(appDirectory, internalPlugins === null || internalPlugins === void 0 ? void 0 : internalPlugins.cli, internalPlugins === null || internalPlugins === void 0 ? void 0 : internalPlugins.autoLoad, autoLoadPlugins);
   await CLIPluginRun({
     cwd,

package/dist/esm-node/{new → utils}/getConfigFile.js

@@ -1,6 +1,6 @@
 import path from "path";
 import { CONFIG_FILE_EXTENSIONS, findExists } from "@modern-js/utils";
-import { DEFAULT_CONFIG_FILE } from "./constants";
+import { DEFAULT_CONFIG_FILE } from "../constants";
 const getConfigFile = (configFile) => findExists(CONFIG_FILE_EXTENSIONS.map((extension) => path.resolve(process.cwd(), `${configFile || DEFAULT_CONFIG_FILE}${extension}`)));
 export {
   getConfigFile

package/dist/esm-node/{new/utils/index.js → utils/isAutoLoadPlugins.js}

@@ -1,10 +1,10 @@
 import { createLoadedConfig } from "@modern-js/plugin-v2/cli";
-async function getIsAutoLoadPlugins(appDirectory, configFile = "modern.config.ts", packageJsonConfig = "ModernConfig") {
+async function isAutoLoadPlugins(appDirectory, configFile = "modern.config.ts", packageJsonConfig = "ModernConfig") {
   var _loaded_config;
   const loaded = await createLoadedConfig(appDirectory, configFile, packageJsonConfig);
   const autoLoadPlugins = (_loaded_config = loaded.config) === null || _loaded_config === void 0 ? void 0 : _loaded_config.autoLoadPlugins;
   return autoLoadPlugins || false;
 }
 export {
-  getIsAutoLoadPlugins
+  isAutoLoadPlugins
 };

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

@@ -1,12 +1,13 @@
 import { loadServerPlugins as loadServerPluginInstances } from "@modern-js/prod-server";
+import { compatibleRequire, createDebugger, dynamicImport, getInternalPlugins, tryResolve } from "@modern-js/utils";
+const debug = createDebugger("load-plugins");
 async function getServerPlugins(api, metaName = "modern-js") {
-  const runner = api.useHookRunners();
-  const { plugins } = await runner._internalServerPlugins({
+  const hooks = api.getHooks();
+  const { plugins } = await hooks._internalServerPlugins.call({
     plugins: []
   });
   const filtedPlugins = plugins.filter((plugin) => plugin.name.includes(metaName));
-  api.setAppContext({
-    ...api.useAppContext(),
+  api.updateAppContext({
     serverPlugins: filtedPlugins
   });
   return filtedPlugins;
@@ -16,7 +17,36 @@ async function loadServerPlugins(api, appDirectory, metaName) {
   const instances = await loadServerPluginInstances(plugins, appDirectory);
   return instances;
 }
+const resolveCliPlugin = async (p, appDirectory) => {
+  const pkg = typeof p === "string" ? p : p[0];
+  const pluginOptions = typeof p === "string" ? void 0 : p[1];
+  const path = tryResolve(pkg, appDirectory);
+  let module;
+  try {
+    module = await compatibleRequire(path);
+  } catch (e) {
+    ({ default: module } = await dynamicImport(path));
+  }
+  if (typeof module === "function") {
+    const result = module(pluginOptions);
+    return result;
+  }
+  return module;
+};
+const loadInternalPlugins = async (appDirectory, internalPlugins, autoLoad, autoLoadPlugins) => {
+  const plugins = [
+    ...autoLoadPlugins ? getInternalPlugins(appDirectory, internalPlugins) : [],
+    ...autoLoad ? getInternalPlugins(appDirectory, autoLoad) : []
+  ];
+  const loadedPlugins = await Promise.all(plugins.map((plugin) => {
+    const loadedPlugin = resolveCliPlugin(plugin, appDirectory);
+    debug(`resolve plugin %s: %s`, plugin, loadedPlugin);
+    return loadedPlugin;
+  }));
+  return loadedPlugins;
+};
 export {
   getServerPlugins,
+  loadInternalPlugins,
   loadServerPlugins
 };

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

@@ -6,14 +6,6 @@ const printInstructions = async (hooks, appContext, config) => {
   });
   logger.log(instructions);
 };
-const printInstructionsCompat = async (hookRunners, appContext, config) => {
-  const message = prettyInstructions(appContext, config);
-  const { instructions } = await hookRunners.beforePrintInstructions({
-    instructions: message
-  });
-  logger.log(instructions);
-};
 export {
-  printInstructions,
-  printInstructionsCompat
+  printInstructions
 };

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

@@ -1,12 +1,12 @@
 import { cli } from "@modern-js/plugin-v2/cli";
 import { chalk, clearConsole, getFullArgv, logger } from "@modern-js/utils";
 import { program } from "@modern-js/utils/commander";
-async function restart(hooksRunner, filename) {
+async function restart(hooks, filename) {
   clearConsole();
   logger.info(`Restart because ${chalk.yellow(filename)} is changed...
 `);
   let hasGetError = false;
-  await hooksRunner.beforeRestart();
+  await hooks.onBeforeRestart.call();
   try {
     await cli.init(cli.getPrevInitOptions());
   } catch (err) {

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

@@ -1,4 +1,4 @@
-import { type PluginAPI } from '@modern-js/core';
+import type { CLIPluginAPI } from '@modern-js/plugin-v2';
 import type { AppTools } from '../types';
 import type { BuildOptions } from '../utils/types';
-export declare const build: (api: PluginAPI<AppTools<'shared'>>, options?: BuildOptions) => Promise<void>;
+export declare const build: (api: CLIPluginAPI<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 { CLIPluginAPI } from '@modern-js/plugin-v2';
 import type { AppTools } from '../types';
-export declare const deploy: (api: PluginAPI<AppTools<'shared'>>, options: any) => Promise<void>;
+export declare const deploy: (api: CLIPluginAPI<AppTools<'shared'>>, options: any) => Promise<void>;

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

@@ -1,8 +1,8 @@
-import { type PluginAPI } from '@modern-js/core';
+import type { CLIPluginAPI } from '@modern-js/plugin-v2';
 import { type ApplyPlugins } from '@modern-js/server';
 import type { AppTools } from '../types';
 import type { DevOptions } from '../utils/types';
 export interface ExtraServerOptions {
     applyPlugins?: ApplyPlugins;
 }
-export declare const dev: (api: PluginAPI<AppTools<'shared'>>, options: DevOptions, devServerOptions?: ExtraServerOptions) => Promise<void>;
+export declare const dev: (api: CLIPluginAPI<AppTools<'shared'>>, options: DevOptions, devServerOptions?: ExtraServerOptions) => Promise<void>;

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

@@ -1,10 +1,10 @@
-import type { PluginAPI } from '@modern-js/core';
+import type { CLIPluginAPI } from '@modern-js/plugin-v2';
 import { type Command } from '@modern-js/utils';
 import type { AppTools } from '../types';
-export declare const devCommand: (program: Command, api: PluginAPI<AppTools<'shared'>>) => Promise<void>;
-export declare const buildCommand: (program: Command, api: PluginAPI<AppTools<'shared'>>) => Promise<void>;
-export declare const serverCommand: (program: Command, api: PluginAPI<AppTools<'shared'>>) => void;
-export declare const deployCommand: (program: Command, api: PluginAPI<AppTools<'shared'>>) => void;
+export declare const devCommand: (program: Command, api: CLIPluginAPI<AppTools<'shared'>>) => Promise<void>;
+export declare const buildCommand: (program: Command, api: CLIPluginAPI<AppTools<'shared'>>) => Promise<void>;
+export declare const serverCommand: (program: Command, api: CLIPluginAPI<AppTools<'shared'>>) => void;
+export declare const deployCommand: (program: Command, api: CLIPluginAPI<AppTools<'shared'>>) => void;
 export declare const newCommand: (program: Command, locale: string) => void;
-export declare const inspectCommand: (program: Command, api: PluginAPI<AppTools<'shared'>>) => void;
+export declare const inspectCommand: (program: Command, api: CLIPluginAPI<AppTools<'shared'>>) => void;
 export declare const upgradeCommand: (program: Command) => void;

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

@@ -1,4 +1,4 @@
-import type { PluginAPI } from '@modern-js/core';
+import type { CLIPluginAPI } from '@modern-js/plugin-v2';
 import type { AppTools } from '../types';
 import type { InspectOptions } from '../utils/types';
-export declare const inspect: (api: PluginAPI<AppTools<'shared'>>, options: InspectOptions) => Promise<import("@rsbuild/core").InspectConfigResult<"rspack">>;
+export declare const inspect: (api: CLIPluginAPI<AppTools<'shared'>>, options: InspectOptions) => Promise<import("@rsbuild/core").InspectConfigResult<"rspack">>;

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

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

package/dist/types/{new/compat → compat}/hooks.d.ts

@@ -1,7 +1,7 @@
 import type { InternalContext } from '@modern-js/plugin-v2';
-import type { AppTools } from '../../types';
+import type { AppTools } from '../types';
 /**
  * old plugin useHookRunners function result
  */
-export declare function getHookRunners(context: InternalContext<AppTools>): Record<string, any>;
+export declare function getHookRunners(context: InternalContext<AppTools<'shared'>>): Record<string, any>;
 export declare function handleSetupResult(setupResult: Record<string, (...args: any) => any>, api: Record<string, any>): void;

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

@@ -0,0 +1,2 @@
+import type { AppTools, CliPluginFuture } from '../types';
+export declare const compatPlugin: () => CliPluginFuture<AppTools<'shared'>>;

package/dist/types/index.d.ts

@@ -1,10 +1,12 @@
-import { appTools } from './new/index';
-export { appTools };
-export { initAppContext } from './new/index';
+import type { AppTools, AppToolsOptions, CliPluginFuture } from './types';
+import { initAppContext } from './utils/initAppContext';
+export * from './defineConfig';
+export declare const appTools: (options?: AppToolsOptions) => CliPluginFuture<AppTools<'shared'>>;
 export { defineConfig, defineLegacyConfig } from './defineConfig';
 export { mergeConfig } from '@modern-js/core';
 export type { RuntimeUserConfig } from './types/config';
 export { dev } from './commands/dev';
 export type { DevOptions } from './utils/types';
 export * from './types';
+export { initAppContext };
 export default appTools;

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

@@ -5,3 +5,4 @@ export declare const getServerRoutes: (entrypoints: Entrypoint[], { appContext,
     appContext: AppToolsContext<'shared'>;
     config: AppNormalizedConfig<'shared'>;
 }) => ServerRoute[];
+export declare const getProdServerRoutes: (distDirectory: string) => any;

package/dist/types/plugins/analyze/utils.d.ts

@@ -6,4 +6,5 @@ export declare const parseModule: ({ source, filename, }: {
 }) => Promise<readonly [imports: readonly import("es-module-lexer").ImportSpecifier[], exports: readonly import("es-module-lexer").ExportSpecifier[], facade: boolean]>;
 export declare const getServerCombinedModueFile: (internalDirectory: string, entryName: string) => string;
 export declare const checkIsBuildCommands: () => boolean;
+export declare const checkIsServeCommand: () => boolean;
 export declare const isSubDirOrEqual: (parent: string, child: string) => boolean;

package/dist/types/plugins/serverBuild.d.ts

@@ -1,3 +1,3 @@
-import type { AppTools, CliPlugin } from '../types';
-declare const _default: () => CliPlugin<AppTools>;
+import type { AppTools, CliPluginFuture } from '../types';
+declare const _default: () => CliPluginFuture<AppTools<'shared'>>;
 export default _default;

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

@@ -40,7 +40,6 @@ export interface AppToolsUserConfig<B extends Bundler> {
     testing?: TestingUserConfig;
     builderPlugins?: Array<LooseRsbuildPlugin | UniBuilderPlugin>;
     performance?: PerformanceUserConfig;
-    devtools?: any;
     environments?: RsbuildConfig['environments'];
 }
 interface SharedNormalizedConfig<RawConfig> {

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

@@ -5,6 +5,7 @@ import type { AppToolsHooks } from './hooks';
 import type { AppToolsLegacyNormalizedConfig, AppToolsLegacyUserConfig } from './legacyConfig';
 import type { AppToolsExtendAPI, AppToolsExtendContext, AppToolsExtendHooks } from './new';
 import type { Bundler } from './utils';
+export type { CLIPluginExtends };
 export * from './hooks';
 export * from './config';
 export * from './legacyConfig';
@@ -33,3 +34,4 @@ export type AppToolsOptions = {
      * */
     bundler?: 'rspack' | 'webpack' | 'experimental-rspack';
 };
+export type { AppToolsExtendAPI, AppToolsExtendContext, AppToolsExtendHooks, AppToolsContext, AppToolsHooks as AppToolsFeatureHooks, } from './new';