@modern-js/app-tools 2.53.1-alpha.4 → 2.54.1-alpha.0

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

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import { findExists, ensureAbsolutePath, JS_EXTENSIONS } from "@modern-js/utils";
+import { INDEX_FILE_NAME } from "./constants";
+import { isDefaultExportFunction } from "./isDefaultExportFunction";
+const hasIndex = (dir) => findExists(JS_EXTENSIONS.map((ext) => path.resolve(dir, `${INDEX_FILE_NAME}${ext}`)));
+const isBundleEntry = async (hookRunners, dir) => {
+  return (await hookRunners.checkEntryPoint({
+    path: dir,
+    entry: false
+  })).entry || hasIndex(dir);
+};
+const scanDir = (hookRunners, dirs) => Promise.all(dirs.map(async (dir) => {
+  const indexFile = hasIndex(dir);
+  const customBootstrap = isDefaultExportFunction(indexFile) ? indexFile : false;
+  const entryName = path.basename(dir);
+  if (indexFile && !customBootstrap) {
+    return {
+      entryName,
+      isMainEntry: false,
+      entry: indexFile,
+      absoluteEntryDir: path.resolve(dir),
+      isAutoMount: false,
+      customBootstrap
+    };
+  }
+  const entryFile = (await hookRunners.checkEntryPoint({
+    path: dir,
+    entry: false
+  })).entry;
+  if (entryFile) {
+    return {
+      entryName,
+      isMainEntry: false,
+      entry: entryFile,
+      absoluteEntryDir: path.resolve(dir),
+      isAutoMount: true,
+      customBootstrap
+    };
+  }
+  throw Error("There is no valid entry point in the current project!");
+}));
+const getFileSystemEntry = async (hookRunners, appContext, config) => {
+  const { appDirectory } = appContext;
+  const { source: { entriesDir, disableEntryDirs } } = config;
+  let disabledDirs = [];
+  if (disableEntryDirs && Array.isArray(disableEntryDirs)) {
+    disabledDirs = disableEntryDirs === null || disableEntryDirs === void 0 ? void 0 : disableEntryDirs.map((dir) => ensureAbsolutePath(appDirectory, dir));
+  }
+  const src = ensureAbsolutePath(appDirectory, entriesDir || "");
+  if (fs.existsSync(src)) {
+    if (fs.statSync(src).isDirectory()) {
+      if (await isBundleEntry(hookRunners, src)) {
+        return scanDir(hookRunners, [
+          src
+        ]);
+      }
+      const dirs = [];
+      await Promise.all(fs.readdirSync(src).map(async (filename) => {
+        const file = path.join(src, filename);
+        if (fs.statSync(file).isDirectory() && await isBundleEntry(hookRunners, file) && !disabledDirs.includes(file)) {
+          dirs.push(file);
+        }
+      }));
+      return scanDir(hookRunners, dirs);
+    } else {
+      throw Error(`source.entriesDir accept a directory.`);
+    }
+  } else {
+    throw Error(`src dir ${entriesDir} not found.`);
+  }
+};
+export {
+  getFileSystemEntry
+};

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

@@ -1,7 +1,7 @@
 import path from "path";
 import fs from "fs";
 import { urlJoin, isPlainObject, removeLeadingSlash, getEntryOptions, SERVER_BUNDLE_DIRECTORY, removeTailSlash, SERVER_WORKER_BUNDLE_DIRECTORY } from "@modern-js/utils";
-import { isMainEntry } from "../utils/routes";
+import { isMainEntry } from "../../utils/routes";
 import { walkDirectory } from "./utils";
 const applyBaseUrl = (baseUrl, routes) => {
   if (baseUrl) {

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/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");

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");

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");

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'>>;

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

@@ -0,0 +1,19 @@
+import type { Entrypoint } from '@modern-js/types';
+import type { RuntimePlugin } from '../../types';
+export declare const index: ({ mountId, imports, renderFunction, exportStatement, }: {
+    mountId: string;
+    imports: string;
+    exportStatement: string;
+    renderFunction: string;
+}) => string;
+export declare const renderFunction: ({ plugins, customBootstrap, fileSystemRoutes, customRuntimeConfig, }: {
+    plugins: RuntimePlugin[];
+    customBootstrap?: string | false | undefined;
+    customRuntimeConfig?: string | false | undefined;
+    fileSystemRoutes: Entrypoint['fileSystemRoutes'];
+}) => string;
+export declare const html: (partials: {
+    top: string[];
+    head: string[];
+    body: string[];
+}) => string;

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

@@ -1,22 +1,20 @@
 import type { Entrypoint } from '@modern-js/types';
-import type { ImportStatement } from '../types';
+import type { ImportStatement } from '../../types';
 export declare const walkDirectory: (dir: string) => string[];
-export declare const getDefaultImports: ({ entrypoint, srcDirectory, appDirectory, internalSrcAlias, internalDirAlias, }: {
+export declare const getDefaultImports: ({ entrypoint, srcDirectory, appDirectory, internalSrcAlias, internalDirAlias, runtimeConfigFile, customRuntimeConfig, }: {
     entrypoint: Entrypoint;
     srcDirectory: string;
     appDirectory: string;
     internalSrcAlias: string;
     internalDirAlias: string;
+    runtimeConfigFile: string | false;
+    customRuntimeConfig: string | false;
 }) => ImportStatement[];
-export declare const isPageComponentFile: (filePath: string) => boolean;
 export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => string;
 export declare const parseModule: ({ source, filename, }: {
     source: string;
     filename: string;
 }) => Promise<readonly [imports: readonly import("es-module-lexer").ImportSpecifier[], exports: readonly import("es-module-lexer").ExportSpecifier[], facade: boolean]>;
-export declare const hasLoader: (filename: string, source?: string) => Promise<boolean>;
-export declare const hasAction: (filename: string, source?: string) => Promise<boolean>;
-export declare const getServerLoadersFile: (internalDirectory: string, entryName: string) => string;
 export declare const getServerCombinedModueFile: (internalDirectory: string, entryName: string) => string;
 export declare const checkIsBuildCommands: () => boolean;
 export declare const isSubDirOrEqual: (parent: string, child: string) => boolean;

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

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