@modern-js/app-tools 2.53.1-alpha.3 → 2.54.0

package/dist/esm-node/{analyze → plugins/analyze}/index.js

@@ -1,13 +1,12 @@
 import * as path from "path";
 import { createDebugger, findExists, fs, isApiOnly, minimist, isDevCommand, getArgv } from "@modern-js/utils";
-import { cloneDeep } from "@modern-js/utils/lodash";
-import { printInstructions } from "../utils/printInstructions";
-import { generateRoutes, getPathWithoutExt } from "../utils/routes";
-import { emitResolvedConfig } from "../utils/config";
-import { getSelectedEntries } from "../utils/getSelectedEntries";
-import { initialNormalizedConfig } from "../config";
-import { createBuilderGenerator } from "../builder";
-import { checkIsBuildCommands, isPageComponentFile, parseModule, replaceWithAlias } from "./utils";
+import { printInstructions } from "../../utils/printInstructions";
+import { generateRoutes, getPathWithoutExt } from "../../utils/routes";
+import { emitResolvedConfig } from "../../utils/config";
+import { getSelectedEntries } from "../../utils/getSelectedEntries";
+import { initialNormalizedConfig } from "../../config";
+import { createBuilderGenerator } from "../../builder";
+import { checkIsBuildCommands, parseModule, replaceWithAlias } from "./utils";
 import { APP_CONFIG_NAME, APP_INIT_EXPORTED, APP_INIT_IMPORTED } from "./constants";
 import { generateIndexCode } from "./generateCode";
 const debug = createDebugger("plugin-analyze");
@@ -16,7 +15,6 @@ var analyze_default = ({ bundler }) => ({
   setup: (api) => {
     let pagesDir = [];
     let nestedRouteEntries = [];
-    let originEntrypoints = [];
     return {
       async prepare() {
         var _resolvedConfig_source;
@@ -50,7 +48,9 @@ var analyze_default = ({ bundler }) => ({
           import("./generateCode"),
           import("./getHtmlTemplate")
         ]);
-        const entrypoints = getBundleEntry(appContext, resolvedConfig);
+        const { entrypoints } = await hookRunners.modifyEntrypoints({
+          entrypoints: await getBundleEntry(hookRunners, appContext, resolvedConfig)
+        });
         debug(`entrypoints: %o`, entrypoints);
         const initialRoutes = getServerRoutes(entrypoints, {
           appContext,
@@ -68,7 +68,6 @@ var analyze_default = ({ bundler }) => ({
         api.setAppContext(appContext);
         nestedRouteEntries = entrypoints.map((point) => point.nestedRoutesEntry).filter(Boolean);
         pagesDir = entrypoints.map((point) => point.entry).filter((entry) => entry && !path.extname(entry)).concat(nestedRouteEntries);
-        originEntrypoints = cloneDeep(entrypoints);
         const { importsStatemets } = await generateCode(appContext, resolvedConfig, entrypoints, api);
         const htmlTemplates = await getHtmlTemplate(entrypoints, api, {
           appContext,
@@ -212,20 +211,6 @@ var analyze_default = ({ bundler }) => ({
           entrypoint,
           imports
         };
-      },
-      async fileChange(e) {
-        const appContext = api.useAppContext();
-        const { appDirectory } = appContext;
-        const { filename, eventType } = e;
-        const isPageFile = (name) => pagesDir.some((pageDir) => name.includes(pageDir));
-        const absoluteFilePath = path.resolve(appDirectory, filename);
-        const isRouteComponent = isPageFile(absoluteFilePath) && isPageComponentFile(absoluteFilePath);
-        if (isRouteComponent && (eventType === "add" || eventType === "unlink")) {
-          const resolvedConfig = api.useResolvedConfigContext();
-          const { generateCode } = await import("./generateCode");
-          const entrypoints = cloneDeep(originEntrypoints);
-          generateCode(appContext, resolvedConfig, entrypoints, api);
-        }
       }
     };
   }

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

@@ -0,0 +1,75 @@
+import { APP_CONFIG_NAME } from "./constants";
+const index = ({ mountId, imports, renderFunction: renderFunction2, exportStatement }) => `
+const IS_BROWSER = typeof window !== 'undefined' && window.name !== 'nodejs';
+const IS_REACT18 = process.env.IS_REACT18 === 'true';
+const MOUNT_ID = '${mountId}';
+
+${imports}
+
+let AppWrapper = null;
+
+let root = null;
+
+function render() {
+  ${renderFunction2}
+}
+
+AppWrapper = render();
+
+${exportStatement};
+`;
+const renderFunction = ({ plugins, customBootstrap, fileSystemRoutes, customRuntimeConfig }) => {
+  const bootstrap = "bootstrap(AppWrapper, MOUNT_ID, root, ReactDOM)";
+  const runtimePlugins = `...(runtimeConfig?.plugins || []),`;
+  return `
+  const finalAppConfig = {
+    ...App.config,
+    ...typeof ${APP_CONFIG_NAME} === 'function' ? ${APP_CONFIG_NAME}() : {},
+  }
+
+  AppWrapper = createApp({
+    plugins: [
+     ${plugins.map(({ name, options, args }) => `${name}({...${options}, ...finalAppConfig?.${args || name}}),`).join("\n")}
+       ${customRuntimeConfig ? runtimePlugins : ""}
+    ]
+  })(${fileSystemRoutes ? "" : `App`})
+
+
+  if(!AppWrapper.init && typeof appInit !== 'undefined') {
+    AppWrapper.init = appInit;
+  }
+
+
+  if (IS_BROWSER) {
+    ${customBootstrap ? `customBootstrap(AppWrapper, () => ${bootstrap});` : `${bootstrap};`}
+  }
+
+  return AppWrapper
+`;
+};
+const html = (partials) => `
+<!DOCTYPE html>
+<html>
+<head>
+
+  ${partials.top.join("\n")}
+
+  ${partials.head.join("\n")}
+
+</head>
+
+<body>
+  <div id="<%= mountId %>"><!--<?- html ?>--></div>
+  ${partials.body.join("\n")}
+  <!--<?- chunksMap.js ?>-->
+  <!--<?- SSRDataScript ?>-->
+  <!--<?- bottomTemplate ?>-->
+</body>
+
+</html>
+`;
+export {
+  html,
+  index,
+  renderFunction
+};

package/dist/esm-node/{analyze → plugins/analyze}/utils.js

@@ -1,9 +1,9 @@
 import fs from "fs";
 import path from "path";
-import { isReact18, normalizeToPosixPath, fs as fse, getCommand } from "@modern-js/utils";
+import { isReact18, normalizeToPosixPath, getCommand, JS_EXTENSIONS } from "@modern-js/utils";
 import { transform } from "esbuild";
 import { parse } from "es-module-lexer";
-import { ACTION_EXPORT_NAME, FILE_SYSTEM_ROUTES_FILE_NAME, JS_EXTENSIONS, LOADER_EXPORT_NAME } from "./constants";
+import { FILE_SYSTEM_ROUTES_FILE_NAME } from "./constants";
 const walkDirectory = (dir) => fs.readdirSync(dir).reduce((previous, filename) => {
   const filePath = path.join(dir, filename);
   if (fs.statSync(filePath).isDirectory()) {
@@ -18,7 +18,7 @@ const walkDirectory = (dir) => fs.readdirSync(dir).reduce((previous, filename) =
     ];
   }
 }, []);
-const getDefaultImports = ({ entrypoint, srcDirectory, appDirectory, internalSrcAlias, internalDirAlias }) => {
+const getDefaultImports = ({ entrypoint, srcDirectory, appDirectory, internalSrcAlias, internalDirAlias, runtimeConfigFile, customRuntimeConfig }) => {
   const { entryName, fileSystemRoutes, customBootstrap, entry } = entrypoint;
   const imports = [
     {
@@ -89,21 +89,17 @@ const getDefaultImports = ({ entrypoint, srcDirectory, appDirectory, internalSrc
       value: normalizeToPosixPath(entry.replace(srcDirectory, internalSrcAlias))
     });
   }
-  return imports;
-};
-const isPageComponentFile = (filePath) => {
-  if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
-    return false;
-  }
-  if ([
-    ".js",
-    ".jsx",
-    ".ts",
-    ".tsx"
-  ].includes(path.extname(filePath))) {
-    return true;
+  if (customRuntimeConfig) {
+    imports.push({
+      specifiers: [
+        {
+          local: "runtimeConfig"
+        }
+      ],
+      value: path.join(internalSrcAlias, runtimeConfigFile || "")
+    });
   }
-  return false;
+  return imports;
 };
 const replaceWithAlias = (base, filePath, alias) => {
   if (filePath.includes(base)) {
@@ -123,37 +119,6 @@ const parseModule = async ({ source, filename }) => {
   }
   return await parse(content);
 };
-const hasLoader = async (filename, source) => {
-  let content = source;
-  if (!source) {
-    content = (await fse.readFile(filename, "utf-8")).toString();
-  }
-  if (content) {
-    const [, moduleExports] = await parseModule({
-      source: content.toString(),
-      filename
-    });
-    return moduleExports.some((e) => e.n === LOADER_EXPORT_NAME);
-  }
-  return false;
-};
-const hasAction = async (filename, source) => {
-  let content = source;
-  if (!source) {
-    content = (await fse.readFile(filename, "utf-8")).toString();
-  }
-  if (content) {
-    const [, moduleExports] = await parseModule({
-      source: content.toString(),
-      filename
-    });
-    return moduleExports.some((e) => e.n === ACTION_EXPORT_NAME);
-  }
-  return false;
-};
-const getServerLoadersFile = (internalDirectory, entryName) => {
-  return path.join(internalDirectory, entryName, "route-server-loaders.js");
-};
 const getServerCombinedModueFile = (internalDirectory, entryName) => {
   return path.join(internalDirectory, entryName, "server-loader-combined.js");
 };
@@ -181,10 +146,6 @@ export {
   checkIsBuildCommands,
   getDefaultImports,
   getServerCombinedModueFile,
-  getServerLoadersFile,
-  hasAction,
-  hasLoader,
-  isPageComponentFile,
   isSubDirOrEqual,
   parseModule,
   replaceWithAlias,

package/dist/esm-node/plugins/deploy/dependencies/index.js

@@ -1,11 +1,21 @@
-import path from "node:path";
+import path, { isAbsolute } from "node:path";
 import { fs as fse, pkgUp, semver } from "@modern-js/utils";
 import { readPackageJSON } from "pkg-types";
 import { parseNodeModulePath } from "mlly";
-import { linkPackage, writePackage, isFile, findEntryFiles, traceFiles, findPackageParents, resolveTracedPath, readDirRecursive } from "./utils";
-const handleDependencies = async ({ appDir, serverRootDir, includeEntries, entryFilter, modifyPackageJson, copyWholePackage }) => {
+import { linkPackage, writePackage, isFile, findEntryFiles, traceFiles, findPackageParents, resolveTracedPath } from "./utils";
+const handleDependencies = async (appDir, serverRootDir, include, entryFilter) => {
   const base = "/";
   const entryFiles = await findEntryFiles(serverRootDir, entryFilter);
+  const includeEntries = include.map((item) => {
+    if (isAbsolute(item)) {
+      return item;
+    }
+    try {
+      return require.resolve(item);
+    } catch (error) {
+    }
+    return item;
+  });
   const fileTrace = await traceFiles(entryFiles.concat(includeEntries), serverRootDir, base);
   const currentProjectModules = path.join(appDir, "node_modules");
   const tracedFiles = Object.fromEntries(await Promise.all([
@@ -100,17 +110,9 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, entry
       }
       tracedPackage.versions[pkgJSON.version] = tracedPackageVersion;
     }
+    tracedFile.path.startsWith(tracedFile.pkgPath) && tracedPackageVersion.path === tracedFile.pkgPath && tracedPackageVersion.files.push(tracedFile.path);
     tracedFile.pkgName = pkgName;
     tracedFile.pkgVersion = pkgJSON.version;
-    const shouldCopyWholePackage = copyWholePackage === null || copyWholePackage === void 0 ? void 0 : copyWholePackage(pkgName);
-    if (tracedFile.path.startsWith(tracedFile.pkgPath) && tracedPackageVersion.path === tracedFile.pkgPath) {
-      if (shouldCopyWholePackage) {
-        const allFiles = await readDirRecursive(tracedFile.pkgPath);
-        tracedPackageVersion.files.push(...allFiles);
-      } else {
-        tracedPackageVersion.files.push(tracedFile.path);
-      }
-    }
   }
   const multiVersionPkgs = {};
   const singleVersionPackages = [];
@@ -128,11 +130,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, entry
   await Promise.all(singleVersionPackages.map((pkgName) => {
     const pkg = tracedPackages[pkgName];
     const version = Object.keys(pkg.versions)[0];
-    return writePackage({
-      pkg,
-      version,
-      projectDir: serverRootDir
-    });
+    return writePackage(pkg, version, serverRootDir);
   }));
   const projectPkgJson = await readPackageJSON(serverRootDir).catch(() => ({}));
   for (const [pkgName, pkgVersions] of Object.entries(multiVersionPkgs)) {
@@ -159,12 +157,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, entry
     for (const [version, parentPkgs] of versionEntires) {
       const pkg = tracedPackages[pkgName];
       const pkgDestPath = `.modernjs/${pkgName}@${version}/node_modules/${pkgName}`;
-      await writePackage({
-        pkg,
-        version,
-        projectDir: serverRootDir,
-        _pkgPath: pkgDestPath
-      });
+      await writePackage(pkg, version, serverRootDir, pkgDestPath);
       await linkPackage(pkgDestPath, `${pkgName}`, serverRootDir);
       for (const parentPkg of parentPkgs) {
         const parentPkgName = parentPkg.replace(/@[^@]+$/, "");
@@ -173,7 +166,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, entry
     }
   }
   const outputPkgPath = path.join(serverRootDir, "package.json");
-  const newPkgJson = {
+  await fse.writeJSON(outputPkgPath, {
     name: `${projectPkgJson.name || "modernjs-project"}-prod`,
     version: projectPkgJson.version || "0.0.0",
     private: true,
@@ -183,9 +176,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, entry
         Object.keys(pkg.versions)[0]
       ])
     ].sort(([a], [b]) => a.localeCompare(b)))
-  };
-  const finalPkgJson = (modifyPackageJson === null || modifyPackageJson === void 0 ? void 0 : modifyPackageJson(newPkgJson)) || newPkgJson;
-  await fse.writeJSON(outputPkgPath, finalPkgJson);
+  });
 };
 export {
   handleDependencies

package/dist/esm-node/plugins/deploy/dependencies/utils.js

@@ -10,8 +10,7 @@ function applyPublicCondition(pkg) {
     pkg.exports = pkg === null || pkg === void 0 ? void 0 : (_pkg_publishConfig1 = pkg.publishConfig) === null || _pkg_publishConfig1 === void 0 ? void 0 : _pkg_publishConfig1.exports;
   }
 }
-const writePackage = async (options) => {
-  const { pkg, version, projectDir, _pkgPath } = options;
+const writePackage = async (pkg, version, projectDir, _pkgPath) => {
   const pkgPath = _pkgPath || pkg.name;
   for (const src of pkg.versions[version].files) {
     if (src.includes("node_modules")) {

package/dist/esm-node/plugins/deploy/platforms/netlify.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { ROUTE_SPEC_FILE, DEFAULT_SERVER_CONFIG, fs as fse, getInternalPlugins } from "@modern-js/utils";
+import { ROUTE_SPEC_FILE, DEFAULT_SERVER_CONFIG, fs as fse } from "@modern-js/utils";
 import { isMainEntry } from "../../../utils/routes";
 import { genPluginImportsCode, serverAppContenxtTemplate } from "../utils";
 import { handleDependencies } from "../dependencies";
@@ -17,8 +17,8 @@ async function cleanDistDirectory(dir) {
   }
 }
 const createNetlifyPreset = (appContext, modernConfig, needModernServer) => {
-  const { appDirectory, distDirectory, serverInternalPlugins, entrypoints } = appContext;
-  const plugins = getInternalPlugins(appDirectory, serverInternalPlugins);
+  const { appDirectory, distDirectory, entrypoints, serverPlugins } = appContext;
+  const plugins = serverPlugins.map((plugin) => plugin.name);
   const netlifyOutput = path.join(appDirectory, ".netlify");
   const funcsDirectory = path.join(netlifyOutput, "functions");
   const entryFilePath = path.join(funcsDirectory, "index.js");
@@ -91,13 +91,9 @@ const createNetlifyPreset = (appContext, modernConfig, needModernServer) => {
       if (!needModernServer) {
         return;
       }
-      await handleDependencies({
-        appDir: appDirectory,
-        serverRootDir: funcsDirectory,
-        includeEntries: [
-          require.resolve("@modern-js/prod-server")
-        ]
-      });
+      await handleDependencies(appDirectory, funcsDirectory, [
+        "@modern-js/prod-server"
+      ]);
     }
   };
 };

package/dist/esm-node/plugins/deploy/platforms/node.js

@@ -1,10 +1,10 @@
 import path from "node:path";
-import { ROUTE_SPEC_FILE, DEFAULT_SERVER_CONFIG, fs as fse, getInternalPlugins, chalk } from "@modern-js/utils";
+import { ROUTE_SPEC_FILE, DEFAULT_SERVER_CONFIG, fs as fse, chalk } from "@modern-js/utils";
 import { genPluginImportsCode, serverAppContenxtTemplate } from "../utils";
 import { handleDependencies } from "../dependencies";
 const createNodePreset = (appContext, config) => {
-  const { appDirectory, distDirectory, serverInternalPlugins } = appContext;
-  const plugins = getInternalPlugins(appDirectory, serverInternalPlugins);
+  const { appDirectory, distDirectory, serverPlugins } = appContext;
+  const plugins = serverPlugins.map((plugin) => plugin.name);
   const outputDirectory = path.join(appDirectory, ".output");
   const staticDirectory = path.join(outputDirectory, "static");
   const entryFilePath = path.join(outputDirectory, "index.js");
@@ -45,17 +45,9 @@ const createNodePreset = (appContext, config) => {
       const filter = (filePath) => {
         return !filePath.startsWith(staticDirectory);
       };
-      await handleDependencies({
-        appDir: appDirectory,
-        serverRootDir: outputDirectory,
-        includeEntries: [
-          require.resolve("@modern-js/prod-server")
-        ],
-        entryFilter: filter,
-        copyWholePackage: (pkgName) => {
-          return pkgName === "koa";
-        }
-      });
+      await handleDependencies(appDirectory, outputDirectory, [
+        "@modern-js/prod-server"
+      ], filter);
     }
   };
 };

package/dist/esm-node/plugins/deploy/platforms/vercel.js

@@ -1,11 +1,11 @@
 import path from "node:path";
-import { ROUTE_SPEC_FILE, DEFAULT_SERVER_CONFIG, fs as fse, getInternalPlugins } from "@modern-js/utils";
+import { ROUTE_SPEC_FILE, DEFAULT_SERVER_CONFIG, fs as fse } from "@modern-js/utils";
 import { isMainEntry } from "../../../utils/routes";
 import { genPluginImportsCode, serverAppContenxtTemplate } from "../utils";
 import { handleDependencies } from "../dependencies";
 const createVercelPreset = (appContext, modernConfig, needModernServer) => {
-  const { appDirectory, distDirectory, serverInternalPlugins, entrypoints } = appContext;
-  const plugins = getInternalPlugins(appDirectory, serverInternalPlugins);
+  const { appDirectory, distDirectory, entrypoints, serverPlugins } = appContext;
+  const plugins = serverPlugins.map((plugin) => plugin.name);
   const vercelOutput = path.join(appDirectory, ".vercel");
   const outputDirectory = path.join(vercelOutput, "output");
   const funcsDirectory = path.join(outputDirectory, "functions", "index.func");
@@ -103,13 +103,9 @@ const createVercelPreset = (appContext, modernConfig, needModernServer) => {
       if (!needModernServer) {
         return;
       }
-      await handleDependencies({
-        appDir: appDirectory,
-        serverRootDir: funcsDirectory,
-        includeEntries: [
-          require.resolve("@modern-js/prod-server")
-        ]
-      });
+      await handleDependencies(appDirectory, funcsDirectory, [
+        "@modern-js/prod-server"
+      ]);
     }
   };
 };

package/dist/esm-node/{initialize → plugins/initialize}/index.js

@@ -1,5 +1,5 @@
 import { ensureAbsolutePath, getPort, isDev, isDevCommand } from "@modern-js/utils";
-import { checkIsLegacyConfig, createDefaultConfig, createLegacyDefaultConfig, transformNormalizedConfig } from "../config";
+import { checkIsLegacyConfig, createDefaultConfig, createLegacyDefaultConfig, transformNormalizedConfig } from "../../config";
 var initialize_default = ({ bundler }) => ({
   name: "@modern-js/plugin-initialize",
   post: [

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

@@ -1,11 +1,17 @@
 import path from "path";
 import fs from "fs";
-import { SERVER_DIR, SHARED_DIR } from "@modern-js/utils";
+import { SERVER_DIR, SHARED_DIR, getMeta } from "@modern-js/utils";
 import { compile } from "@modern-js/server-utils";
 const TS_CONFIG_FILENAME = "tsconfig.json";
 function checkHasCache(appDir) {
-  const tsFilepath = path.resolve(appDir, "server", "cache.ts");
-  const jsfilepath = path.resolve(appDir, "server", "cache.js");
+  const tsFilepath = path.resolve(appDir, SERVER_DIR, "cache.ts");
+  const jsfilepath = path.resolve(appDir, SERVER_DIR, "cache.js");
+  return fs.existsSync(tsFilepath) || fs.existsSync(jsfilepath);
+}
+function checkHasConfig(appDir, metaName = "modern-js") {
+  const meta = getMeta(metaName);
+  const tsFilepath = path.resolve(appDir, SERVER_DIR, `${meta}.server.ts`);
+  const jsfilepath = path.resolve(appDir, SERVER_DIR, `${meta}.server.js`);
   return fs.existsSync(tsFilepath) || fs.existsSync(jsfilepath);
 }
 var serverBuild_default = () => ({
@@ -13,8 +19,8 @@ var serverBuild_default = () => ({
   setup(api) {
     return {
       async afterBuild() {
-        const { appDirectory, distDirectory } = api.useAppContext();
-        if (!checkHasCache(appDirectory)) {
+        const { appDirectory, distDirectory, metaName } = api.useAppContext();
+        if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) {
           return;
         }
         const modernConfig = api.useResolvedConfigContext();

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

@@ -1,5 +1,5 @@
 import { createDevServer } from "@modern-js/server";
-import { initProdMiddlewares } from "@modern-js/prod-server";
+import { applyPlugins } from "@modern-js/prod-server";
 let server = null;
 const getServer = () => server;
 const setServer = (newServer) => {
@@ -15,7 +15,7 @@ const createServer = async (options) => {
   if (server) {
     server.close();
   }
-  server = await createDevServer(options, initProdMiddlewares);
+  server = await createDevServer(options, applyPlugins);
   return server;
 };
 export {

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

@@ -0,0 +1,21 @@
+import { loadServerPlugins as loadServerPluginInstances } from "@modern-js/prod-server";
+async function getServerPlugins(api) {
+  const runner = api.useHookRunners();
+  const { plugins } = await runner._internalServerPlugins({
+    plugins: []
+  });
+  api.setAppContext({
+    ...api.useAppContext(),
+    serverPlugins: plugins
+  });
+  return plugins;
+}
+async function loadServerPlugins(api, appDirectory) {
+  const plugins = await getServerPlugins(api);
+  const instances = loadServerPluginInstances(plugins, appDirectory);
+  return instances;
+}
+export {
+  getServerPlugins,
+  loadServerPlugins
+};

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import { CopyPluginOptions, WebpackChain } from '@modern-js/uni-builder';
+import { CopyPluginOptions, RspackChain } from '@modern-js/uni-builder';
 import type { AppNormalizedConfig, Bundler, IAppContext } from '../../types';
-export declare function createPublicPattern(appContext: IAppContext, config: AppNormalizedConfig, chain: WebpackChain): {
+export declare function createPublicPattern(appContext: IAppContext, config: AppNormalizedConfig, chain: RspackChain): {
     info: (file: {
         sourceFilename: string;
     }) => {

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

@@ -1,3 +1,10 @@
-export * from './dev';
-export * from './build';
-export * from './serve';
+import { PluginAPI } from '@modern-js/core';
+import { Command } from '@modern-js/utils';
+import { 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 newCommand: (program: Command, locale: string) => void;
+export declare const inspectCommand: (program: Command, api: PluginAPI<AppTools<'shared'>>) => void;
+export declare const upgradeCommand: (program: Command) => void;

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

@@ -1,4 +1,4 @@
 import { AppNormalizedConfig, IAppContext } from '../../types';
 export declare function initHtmlConfig(config: AppNormalizedConfig<'shared'>, appContext: IAppContext): AppNormalizedConfig<'shared'>['html'];
 export declare function initSourceConfig(config: AppNormalizedConfig<'shared'>, appContext: IAppContext, bundler: 'webpack' | 'rspack'): void;
-export declare function createBuilderModuleScope(config: AppNormalizedConfig<'webpack'>): any;
+export declare function createBuilderModuleScope(config: AppNormalizedConfig<'webpack'>): (string | RegExp)[] | undefined;

package/dist/types/exports/server.d.ts

@@ -1 +1,5 @@
+import { UnstableMiddleware, UnstableMiddlewareContext, UnstableNext } from '@modern-js/types';
+export type RenderMiddleware = UnstableMiddleware;
+export type RenderMiddlewareContext = UnstableMiddlewareContext;
+export type RenderNext = UnstableNext;
 export { defineServerConfig as defineConfig } from '../utils/config';

package/dist/types/index.d.ts

@@ -1,13 +1,10 @@
-import { Command } from '@modern-js/utils';
-import { CliPlugin, PluginAPI } from '@modern-js/core';
+import { CliPlugin } from '@modern-js/core';
 import { AppTools } from './types';
+export { dev } from './commands/dev';
 export { mergeConfig } from '@modern-js/core';
-export { dev } from './commands';
 export * from './defineConfig';
 export * from './types';
 export type { RuntimeUserConfig } from './types/config';
-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 type AppToolsOptions = {
     /**
      * Specify which bundler to use for the build.

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

@@ -0,0 +1,9 @@
+export declare const INDEX_FILE_NAME = "index";
+export declare const FILE_SYSTEM_ROUTES_FILE_NAME = "routes.js";
+export declare const ENTRY_POINT_FILE_NAME = "index.jsx";
+export declare const ENTRY_BOOTSTRAP_FILE_NAME = "bootstrap.jsx";
+export declare const HTML_PARTIALS_FOLDER = "html";
+export declare const HTML_PARTIALS_EXTENSIONS: string[];
+export declare const APP_CONFIG_NAME = "config";
+export declare const APP_INIT_EXPORTED = "init";
+export declare const APP_INIT_IMPORTED = "appInit";

package/dist/types/{analyze → plugins/analyze}/generateCode.d.ts

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

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

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

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

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

package/dist/types/{analyze → plugins/analyze}/getHtmlTemplate.d.ts

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

package/dist/types/{analyze → plugins/analyze}/getServerRoutes.d.ts

@@ -1,6 +1,6 @@
 import type { IAppContext } from '@modern-js/core';
 import type { Entrypoint, ServerRoute } from '@modern-js/types';
-import type { AppNormalizedConfig } from '../types';
+import type { AppNormalizedConfig } from '../../types';
 export declare const getServerRoutes: (entrypoints: Entrypoint[], { appContext, config, }: {
     appContext: IAppContext;
     config: AppNormalizedConfig<'shared'>;

package/dist/types/{analyze → plugins/analyze}/index.d.ts

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