@modern-js/runtime 2.53.0 → 2.54.1

package/dist/esm-node/router/cli/constants.js

@@ -0,0 +1,47 @@
+const PAGES_DIR_NAME = "pages";
+const NESTED_ROUTES_DIR = "routes";
+const FILE_SYSTEM_ROUTES_FILE_NAME = "routes.js";
+const LOADER_EXPORT_NAME = "loader";
+const ACTION_EXPORT_NAME = "action";
+const TEMP_LOADERS_DIR = "__loaders__";
+const FILE_SYSTEM_ROUTES_LAYOUT = "_layout";
+const FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = "_app";
+const FILE_SYSTEM_ROUTES_INDEX = "index";
+const FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/;
+const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = /^\[(\S+)\]([*+?]?)$/;
+const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = "internal_components";
+const NESTED_ROUTE = {
+  LAYOUT_FILE: "layout",
+  LAYOUT_CONFIG_FILE: "layout.config",
+  LAYOUT_LOADER_FILE: "layout.loader",
+  LAYOUT_DATA_FILE: "layout.data",
+  LAYOUT_CLIENT_LOADER: "layout.data.client",
+  PAGE_FILE: "page",
+  PAGE_CONFIG_FILE: "page.config",
+  PAGE_LOADER_FILE: "page.loader",
+  PAGE_DATA_FILE: "page.data",
+  PAGE_CLIENT_LOADER: "page.data.client",
+  SPLATE_FILE: "$",
+  SPLATE_CONFIG_FILE: "$.config",
+  SPLATE_LOADER_FILE: "$.loader",
+  SPLATE_DATA_FILE: "$.data",
+  SPLATE_CLIENT_DATA: "$.data.client",
+  LOADING_FILE: "loading",
+  ERROR_FILE: "error",
+  LOADER_FILE: "loader"
+};
+export {
+  ACTION_EXPORT_NAME,
+  FILE_SYSTEM_ROUTES_COMPONENTS_DIR,
+  FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP,
+  FILE_SYSTEM_ROUTES_FILE_NAME,
+  FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT,
+  FILE_SYSTEM_ROUTES_IGNORED_REGEX,
+  FILE_SYSTEM_ROUTES_INDEX,
+  FILE_SYSTEM_ROUTES_LAYOUT,
+  LOADER_EXPORT_NAME,
+  NESTED_ROUTE,
+  NESTED_ROUTES_DIR,
+  PAGES_DIR_NAME,
+  TEMP_LOADERS_DIR
+};

package/dist/esm-node/router/cli/entry.js

@@ -0,0 +1,50 @@
+import path from "path";
+import { JS_EXTENSIONS, findExists, fs, isRouterV5 } from "@modern-js/utils";
+import { FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT, NESTED_ROUTES_DIR, PAGES_DIR_NAME } from "./constants";
+const hasPages = (dir) => fs.existsSync(path.join(dir, PAGES_DIR_NAME));
+const hasNestedRoutes = (dir) => fs.existsSync(path.join(dir, NESTED_ROUTES_DIR));
+const isRouteEntry = (dir) => {
+  if (hasNestedRoutes(dir)) {
+    return path.join(dir, NESTED_ROUTES_DIR);
+  }
+  if (hasPages(dir)) {
+    return path.join(dir, PAGES_DIR_NAME);
+  }
+  return false;
+};
+const modifyEntrypoints = (entrypoints, config = {}) => {
+  return entrypoints.map((entrypoint) => {
+    if (!entrypoint.isAutoMount) {
+      return entrypoint;
+    }
+    const isHasNestedRoutes = hasNestedRoutes(entrypoint.absoluteEntryDir);
+    const isHasPages = hasPages(entrypoint.absoluteEntryDir);
+    if (!isHasNestedRoutes && !isHasPages) {
+      return entrypoint;
+    }
+    if (entrypoint.fileSystemRoutes && !isRouterV5(config)) {
+      entrypoint.nestedRoutesEntry = entrypoint.entry;
+    } else if (!entrypoint.fileSystemRoutes) {
+      entrypoint.fileSystemRoutes = {
+        globalApp: findExists(JS_EXTENSIONS.map((ext) => path.resolve(entrypoint.absoluteEntryDir, `./${PAGES_DIR_NAME}/${FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT}${ext}`)))
+      };
+      if (isHasPages) {
+        entrypoint.entry = path.join(entrypoint.absoluteEntryDir, PAGES_DIR_NAME);
+        entrypoint.pageRoutesEntry = entrypoint.entry;
+      }
+      if (isHasNestedRoutes) {
+        entrypoint.entry = path.join(entrypoint.absoluteEntryDir, NESTED_ROUTES_DIR);
+        entrypoint.nestedRoutesEntry = entrypoint.entry;
+      }
+    } else {
+      throw Error("Custom entries with conventional routing not support use react router v5!");
+    }
+    return entrypoint;
+  });
+};
+export {
+  hasNestedRoutes,
+  hasPages,
+  isRouteEntry,
+  modifyEntrypoints
+};

package/dist/esm-node/router/cli/handler.js

@@ -0,0 +1,36 @@
+import path from "path";
+import { cloneDeep } from "@modern-js/utils/lodash";
+import { modifyEntrypoints } from "./entry";
+import { isPageComponentFile } from "./code/utils";
+let originEntrypoints = [];
+async function handleModifyEntrypoints(api, entrypoints) {
+  const config = api.useResolvedConfigContext();
+  const newEntryPoints = modifyEntrypoints(entrypoints, config);
+  const appContext = api.useAppContext();
+  const resolvedConfig = api.useResolvedConfigContext();
+  appContext.entrypoints = newEntryPoints;
+  originEntrypoints = cloneDeep(newEntryPoints);
+  const { generateCode } = await import("./code");
+  await generateCode(appContext, resolvedConfig, entrypoints, api);
+  return newEntryPoints;
+}
+async function handleFileChange(api, e) {
+  const appContext = api.useAppContext();
+  const { appDirectory, entrypoints } = appContext;
+  const { filename, eventType } = e;
+  const nestedRouteEntries = entrypoints.map((point) => point.nestedRoutesEntry).filter(Boolean);
+  const pagesDir = entrypoints.map((point) => point.entry).filter((entry) => entry && !path.extname(entry)).concat(nestedRouteEntries);
+  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("./code");
+    const entrypoints2 = cloneDeep(originEntrypoints);
+    await generateCode(appContext, resolvedConfig, entrypoints2, api);
+  }
+}
+export {
+  handleFileChange,
+  handleModifyEntrypoints
+};

package/dist/esm-node/router/cli/index.js

@@ -1,4 +1,8 @@
 import { getEntryOptions, createRuntimeExportsUtils, isRouterV5 as isV5 } from "@modern-js/utils";
+import { isRouteEntry } from "./entry";
+import { handleFileChange, handleModifyEntrypoints } from "./handler";
+import { isRouteEntry as isRouteEntry2 } from "./entry";
+import { handleFileChange as handleFileChange2, handleModifyEntrypoints as handleModifyEntrypoints2 } from "./handler";
 const PLUGIN_IDENTIFIER = "router";
 const ROUTES_IDENTIFIER = "routes";
 const routerPlugin = () => ({
@@ -10,6 +14,12 @@ const routerPlugin = () => ({
     const runtimeConfigMap = /* @__PURE__ */ new Map();
     let pluginsExportsUtils;
     return {
+      checkEntryPoint({ path, entry }) {
+        return {
+          path,
+          entry: entry || isRouteEntry(path)
+        };
+      },
       config() {
         const appContext = api.useAppContext();
         pluginsExportsUtils = createRuntimeExportsUtils(appContext.internalDirectory, "plugins");
@@ -29,6 +39,12 @@ const routerPlugin = () => ({
           }
         };
       },
+      async modifyEntrypoints({ entrypoints }) {
+        const newEntryPoints = await handleModifyEntrypoints(api, entrypoints);
+        return {
+          entrypoints: newEntryPoints
+        };
+      },
       modifyEntryImports({ entrypoint, imports }) {
         const { entryName, isMainEntry, fileSystemRoutes } = entrypoint;
         const userConfig = api.useResolvedConfigContext();
@@ -80,6 +96,9 @@ const routerPlugin = () => ({
         if (!isV5(userConfig)) {
           pluginsExportsUtils.addExport(`export { default as router } from '@modern-js/runtime/router'`);
         }
+      },
+      async fileChange(e) {
+        await handleFileChange(api, e);
       }
     };
   }
@@ -87,5 +106,8 @@ const routerPlugin = () => ({
 var cli_default = routerPlugin;
 export {
   cli_default as default,
+  handleFileChange2 as handleFileChange,
+  handleModifyEntrypoints2 as handleModifyEntrypoints,
+  isRouteEntry2 as isRouteEntry,
   routerPlugin
 };

package/dist/esm-node/router/runtime/plugin.js

@@ -55,10 +55,11 @@ const routerPlugin = ({
             context
           });
         },
-        hoc: ({ App }, next) => {
+        hoc: ({ App, config }, next) => {
           if (!finalRouteConfig && !createRoutes) {
             return next({
-              App
+              App,
+              config
             });
           }
           const getRouteApp = () => {
@@ -132,11 +133,13 @@ const routerPlugin = ({
           }
           if (routesConfig === null || routesConfig === void 0 ? void 0 : routesConfig.globalApp) {
             return next({
-              App: hoistNonReactStatics(RouteApp, routesConfig.globalApp)
+              App: hoistNonReactStatics(RouteApp, routesConfig.globalApp),
+              config
             });
           }
           return next({
-            App: RouteApp
+            App: RouteApp,
+            config
           });
         },
         pickContext: ({ context, pickedContext }, next) => {

package/dist/esm-node/router/runtime/plugin.node.js

@@ -53,7 +53,7 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
               context
             });
           }
-          const { request, mode: ssrMode, nonce } = context.ssrContext;
+          const { request, mode: ssrMode, nonce, loaderFailureMode = "errorBoundary" } = context.ssrContext;
           const baseUrl = originalBaseUrl || request.baseUrl;
           const _basename = baseUrl === "/" ? urlJoin(baseUrl, basename) : baseUrl;
           const { reporter, serverTiming } = context.ssrContext;
@@ -83,6 +83,10 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
           if (routerContext instanceof Response) {
             return routerContext;
           }
+          if (routerContext.statusCode >= 500 && routerContext.statusCode < 600 && loaderFailureMode === "clientRender") {
+            routerContext.statusCode = 200;
+            throw routerContext.errors[0];
+          }
           const router = createStaticRouter(routes, routerContext);
           context.remixRouter = router;
           context.routerContext = routerContext;
@@ -92,10 +96,11 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
             context
           });
         },
-        hoc: ({ App }, next) => {
+        hoc: ({ App, config }, next) => {
           if (!routesConfig) {
             return next({
-              App
+              App,
+              config
             });
           }
           const getRouteApp = () => {
@@ -122,11 +127,13 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
           const RouteApp = getRouteApp();
           if (routesConfig === null || routesConfig === void 0 ? void 0 : routesConfig.globalApp) {
             return next({
-              App: hoistNonReactStatics(RouteApp, routesConfig.globalApp)
+              App: hoistNonReactStatics(RouteApp, routesConfig.globalApp),
+              config
             });
           }
           return next({
-            App: RouteApp
+            App: RouteApp,
+            config
           });
         },
         pickContext: ({ context, pickedContext }, next) => {

package/dist/esm-node/ssr/index.node.js

@@ -18,6 +18,7 @@ const ssr = (config = {}) => ({
         context.ssrContext.request = formatServer(request);
         context.ssrContext.mode = config.mode;
         context.ssrContext.tracker = createSSRTracker(context.ssrContext);
+        context.ssrContext.loaderFailureMode = config.loaderFailureMode;
         if (!context.ssrContext.htmlModifiers) {
           context.ssrContext.htmlModifiers = [];
         }

package/dist/esm-node/state/runtime/plugin.js

@@ -35,7 +35,7 @@ const state = (config) => ({
   setup: () => {
     const storeConfig = getStoreConfig(config);
     return {
-      hoc({ App }, next) {
+      hoc({ App, config: config2 }, next) {
         const getStateApp = (props) => {
           const context = useContext(RuntimeReactContext);
           return /* @__PURE__ */ _jsx(Provider, {
@@ -47,7 +47,8 @@ const state = (config) => ({
           });
         };
         return next({
-          App: hoistNonReactStatics(getStateApp, App)
+          App: hoistNonReactStatics(getStateApp, App),
+          config: config2
         });
       },
       init({ context }, next) {

package/dist/types/cli/constants.d.ts

@@ -0,0 +1 @@
+export declare const APP_FILE_NAME = "App";

package/dist/types/cli/entry.d.ts

@@ -0,0 +1 @@
+export declare const isRuntimeEntry: (dir: string) => string | false;

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

@@ -1,3 +1,4 @@
 import type { CliPlugin, AppTools } from '@modern-js/app-tools';
+export { isRuntimeEntry } from './entry';
 export declare const runtimePlugin: () => CliPlugin<AppTools>;
 export default runtimePlugin;

package/dist/types/core/compatible.d.ts

@@ -1,13 +1,17 @@
 import React from 'react';
 import type { Renderer } from 'react-dom';
 import type { hydrateRoot, createRoot } from 'react-dom/client';
-import { RuntimeContext, TRuntimeContext } from '../runtimeContext';
-import { Plugin } from './plugin';
+import { RuntimeContext, TRuntimeContext } from './context/runtime';
+import { Plugin, runtime } from './plugin';
 export type CreateAppOptions = {
     plugins: Plugin[];
+    /**
+     * In the test cases, we need to execute multiple createApp instances simultaneously, and they must not share the runtime.
+     */
+    runtime?: typeof runtime;
     props?: any;
 };
-export declare const createApp: ({ plugins, props: globalProps, }: CreateAppOptions) => (App?: React.ComponentType<any>) => React.ComponentType<any>;
+export declare const createApp: ({ plugins, runtime, props: globalProps, }: CreateAppOptions) => (App?: React.ComponentType<any>) => React.ComponentType<any>;
 type BootStrap<T = unknown> = (App: React.ComponentType, id: string | HTMLElement | RuntimeContext, root?: any, ReactDOM?: {
     render?: Renderer;
     hydrate?: Renderer;

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

@@ -0,0 +1,14 @@
+import type React from 'react';
+import { AppConfig } from '../common';
+import { Plugin } from './plugin';
+export declare const getConfig: (Component: React.ComponentType<any>) => AppConfig | undefined;
+export declare const defineConfig: (Component: React.ComponentType<any>, config: AppConfig) => React.ComponentType<any>;
+interface RuntimeConfig {
+    plugins: Plugin[];
+}
+/**
+ * This function helps you to autocomplete configuration types.
+ * It accepts a direct config object, or a function that returns a config.
+ */
+export declare const defineRuntimeConfig: (config: RuntimeConfig) => RuntimeConfig;
+export {};

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

@@ -0,0 +1 @@
+export { RuntimeReactContext } from './runtime';

package/dist/types/{runtimeContext.d.ts → core/context/runtime.d.ts}

@@ -1,10 +1,10 @@
 /// <reference types="react" />
 import { Store } from '@modern-js-reduck/store';
 import { type StaticHandlerContext, type Router, type RouterState } from '@modern-js/runtime-utils/remix-router';
-import { createLoaderManager } from './core/loader/loaderManager';
-import { runtime } from './core/plugin';
-import { RouteManifest } from './router/runtime/types';
-import { SSRServerContext } from './ssr/serverRender/types';
+import { createLoaderManager } from '../loader/loaderManager';
+import { PluginRunner, runtime } from '../plugin';
+import { RouteManifest } from '../../router/runtime/types';
+import { SSRServerContext } from '../../ssr/serverRender/types';
 export interface BaseRuntimeContext {
     initialData?: Record<string, unknown>;
     loaderManager: ReturnType<typeof createLoaderManager>;
@@ -40,3 +40,4 @@ export interface BaseTRuntimeContext {
 export interface TRuntimeContext extends BaseTRuntimeContext {
     [key: string]: any;
 }
+export declare const getInitialContext: (runner: PluginRunner) => RuntimeContext;

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

@@ -1,9 +1,9 @@
-export { createPlugin, createRuntime, runtime, registerInit } from './plugin';
+export { runtime } from './plugin';
 export type { Plugin } from './plugin';
-export { defineConfig, getConfig } from './appConfig';
+export { defineConfig, getConfig, defineRuntimeConfig } from './config';
 export * from './compatible';
-export type { TRuntimeContext, RuntimeContext } from '../runtimeContext';
-export { RuntimeReactContext, ServerRouterContext } from '../runtimeContext';
+export type { RuntimeContext } from './context/runtime';
+export { RuntimeReactContext, ServerRouterContext } from './context/runtime';
 export * from './loader';
 export type { SSRData, SSRContainer } from './types';
 export * from '@modern-js/plugin';

package/dist/types/core/plugin/base.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="react" />
+import { PluginOptions, Setup } from '@modern-js/plugin';
+import { RuntimeContext, TRuntimeContext } from '../context/runtime';
+export interface AppProps {
+}
+declare const runtimeHooks: {
+    hoc: import("@modern-js/plugin").Pipeline<{
+        App: React.ComponentType<any>;
+        config: Record<string, any>;
+    }, import("react").ComponentType<any>>;
+    init: import("@modern-js/plugin").AsyncPipeline<{
+        context: RuntimeContext;
+    }, RuntimeContext>;
+    client: import("@modern-js/plugin").AsyncPipeline<{
+        App: React.ComponentType<any>;
+        readonly context: RuntimeContext;
+        ModernRender: (App: React.ReactElement) => void;
+        ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
+    }, void>;
+    server: import("@modern-js/plugin").AsyncPipeline<{
+        App: React.ComponentType<any>;
+        readonly context: RuntimeContext;
+    }, string>;
+    pickContext: import("@modern-js/plugin").Pipeline<{
+        context: RuntimeContext;
+        pickedContext: TRuntimeContext;
+    }, TRuntimeContext>;
+};
+/** All hooks of runtime plugin. */
+export type RuntimeHooks = typeof runtimeHooks;
+/** Plugin options of a runtime plugin. */
+export type Plugin = PluginOptions<RuntimeHooks, Setup<RuntimeHooks>>;
+export declare const createRuntime: () => import("@modern-js/plugin").Manager<{
+    hoc: import("@modern-js/plugin").Pipeline<{
+        App: React.ComponentType<any>;
+        config: Record<string, any>;
+    }, import("react").ComponentType<any>>;
+    init: import("@modern-js/plugin").AsyncPipeline<{
+        context: RuntimeContext;
+    }, RuntimeContext>;
+    client: import("@modern-js/plugin").AsyncPipeline<{
+        App: React.ComponentType<any>;
+        readonly context: RuntimeContext;
+        ModernRender: (App: React.ReactElement) => void;
+        ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
+    }, void>;
+    server: import("@modern-js/plugin").AsyncPipeline<{
+        App: React.ComponentType<any>;
+        readonly context: RuntimeContext;
+    }, string>;
+    pickContext: import("@modern-js/plugin").Pipeline<{
+        context: RuntimeContext;
+        pickedContext: TRuntimeContext;
+    }, TRuntimeContext>;
+}, Record<string, never>>;
+export declare const runtime: import("@modern-js/plugin").Manager<{
+    hoc: import("@modern-js/plugin").Pipeline<{
+        App: React.ComponentType<any>;
+        config: Record<string, any>;
+    }, import("react").ComponentType<any>>;
+    init: import("@modern-js/plugin").AsyncPipeline<{
+        context: RuntimeContext;
+    }, RuntimeContext>;
+    client: import("@modern-js/plugin").AsyncPipeline<{
+        App: React.ComponentType<any>;
+        readonly context: RuntimeContext;
+        ModernRender: (App: React.ReactElement) => void;
+        ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
+    }, void>;
+    server: import("@modern-js/plugin").AsyncPipeline<{
+        App: React.ComponentType<any>;
+        readonly context: RuntimeContext;
+    }, string>;
+    pickContext: import("@modern-js/plugin").Pipeline<{
+        context: RuntimeContext;
+        pickedContext: TRuntimeContext;
+    }, TRuntimeContext>;
+}, Record<string, never>>;
+export type PluginRunner = ReturnType<typeof runtime.init>;
+export {};

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

@@ -0,0 +1,29 @@
+/// <reference types="react" />
+import { runtime, Plugin } from './base';
+export * from './base';
+export interface RuntimeConfig {
+    plugins: Plugin[];
+}
+export declare function registerPlugin(internalPlugins: Plugin[], runtimeConfig?: RuntimeConfig, customRuntime?: typeof runtime): import("@modern-js/plugin").ToRunners<{
+    hoc: import("@modern-js/plugin").Pipeline<{
+        App: import("react").ComponentType<any>;
+        config: Record<string, any>;
+    }, import("react").ComponentType<any>>;
+    init: import("@modern-js/plugin").AsyncPipeline<{
+        context: import("..").RuntimeContext;
+    }, import("..").RuntimeContext>;
+    client: import("@modern-js/plugin").AsyncPipeline<{
+        App: import("react").ComponentType<any>;
+        readonly context: import("..").RuntimeContext;
+        ModernRender: (App: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) => void;
+        ModernHydrate: (App: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>, callback?: (() => void) | undefined) => void;
+    }, void>;
+    server: import("@modern-js/plugin").AsyncPipeline<{
+        App: import("react").ComponentType<any>;
+        readonly context: import("..").RuntimeContext;
+    }, string>;
+    pickContext: import("@modern-js/plugin").Pipeline<{
+        context: import("..").RuntimeContext;
+        pickedContext: import("../context/runtime").TRuntimeContext;
+    }, import("../context/runtime").TRuntimeContext>;
+}>;

package/dist/types/core/plugin/runner.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import { PluginRunner } from './base';
+export declare function setGlobalRunner(runner: PluginRunner): void;
+export declare function getGlobalRunner(): import("@modern-js/plugin").ToRunners<{
+    hoc: import("@modern-js/plugin").Pipeline<{
+        App: import("react").ComponentType<any>;
+        config: Record<string, any>;
+    }, import("react").ComponentType<any>>;
+    init: import("@modern-js/plugin").AsyncPipeline<{
+        context: import("..").RuntimeContext;
+    }, import("..").RuntimeContext>;
+    client: import("@modern-js/plugin").AsyncPipeline<{
+        App: import("react").ComponentType<any>;
+        readonly context: import("..").RuntimeContext;
+        ModernRender: (App: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) => void;
+        ModernHydrate: (App: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>, callback?: (() => void) | undefined) => void;
+    }, void>;
+    server: import("@modern-js/plugin").AsyncPipeline<{
+        App: import("react").ComponentType<any>;
+        readonly context: import("..").RuntimeContext;
+    }, string>;
+    pickContext: import("@modern-js/plugin").Pipeline<{
+        context: import("..").RuntimeContext;
+        pickedContext: import("../context/runtime").TRuntimeContext;
+    }, import("../context/runtime").TRuntimeContext>;
+}>;

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@ import type { RouterConfig } from './router';
 export type { Plugin } from './core';
 export type { AppConfig } from './common';
 export { isBrowser } from './common';
-export type { BaseRuntimeContext, RuntimeContext, BaseTRuntimeContext, TRuntimeContext, } from './runtimeContext';
+export type { BaseRuntimeContext, RuntimeContext, BaseTRuntimeContext, } from './core/context/runtime';
 export type { RuntimeUserConfig } from './config';
-export { createApp, createPlugin, useLoader, bootstrap, RuntimeReactContext, defineConfig, registerInit, useRuntimeContext, } from './core';
+export { createApp, useLoader, bootstrap, RuntimeReactContext, defineConfig, defineRuntimeConfig, useRuntimeContext, } from './core';
 export { StateConfig, RouterConfig };

package/dist/types/router/cli/code/getClientRoutes/getRoutes.d.ts

@@ -0,0 +1,8 @@
+import type { Entrypoint, NestedRouteForCli, PageRoute } from '@modern-js/types';
+export declare const getClientRoutes: ({ entrypoint, srcDirectory, srcAlias, internalDirectory, internalDirAlias, }: {
+    entrypoint: Entrypoint;
+    srcDirectory: string;
+    srcAlias: string;
+    internalDirectory: string;
+    internalDirAlias: string;
+}) => (NestedRouteForCli | PageRoute)[];

package/dist/types/router/cli/code/getClientRoutes/getRoutesLegacy.d.ts

@@ -0,0 +1,9 @@
+import type { Entrypoint, RouteLegacy } from '@modern-js/types';
+export type { RouteLegacy as Route };
+export declare const getClientRoutes: ({ entrypoint, srcDirectory, srcAlias, internalDirectory, internalDirAlias, }: {
+    entrypoint: Entrypoint;
+    srcDirectory: string;
+    srcAlias: string;
+    internalDirectory: string;
+    internalDirAlias: string;
+}) => RouteLegacy[];

package/dist/types/router/cli/code/getClientRoutes/index.d.ts

@@ -0,0 +1,2 @@
+export { getClientRoutes } from './getRoutes';
+export { getClientRoutes as getClientRoutesLegacy } from './getRoutesLegacy';

package/dist/types/router/cli/code/getClientRoutes/utils.d.ts

@@ -0,0 +1,5 @@
+declare const debug: import("@modern-js/utils/compiled/debug").Debugger;
+export { debug };
+export declare const findLayout: (dir: string) => string | false;
+export declare const getRouteWeight: (route: string) => number;
+export declare const shouldSkip: (file: string) => boolean;

package/dist/types/router/cli/code/index.d.ts

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

package/dist/types/router/cli/code/makeLegalIdentifier.d.ts

@@ -0,0 +1 @@
+export declare function makeLegalIdentifier(str: string): string;

package/dist/types/router/cli/code/nestedRoutes.d.ts

@@ -0,0 +1,7 @@
+import type { NestedRouteForCli } from '@modern-js/types';
+export declare const getRouteId: (componentPath: string, routesDir: string, entryName: string, isMainEntry: boolean) => string;
+export declare const optimizeRoute: (routeTree: NestedRouteForCli) => NestedRouteForCli[];
+export declare const walk: (dirname: string, rootDir: string, alias: {
+    name: string;
+    basename: string;
+}, entryName: string, isMainEntry: boolean, oldVersion: boolean) => Promise<NestedRouteForCli | NestedRouteForCli[] | null>;

package/dist/types/router/cli/code/templates.d.ts

@@ -0,0 +1,14 @@
+import type { Entrypoint, NestedRouteForCli, PageRoute, RouteLegacy, SSRMode } from '@modern-js/types';
+import type { AppNormalizedConfig, IAppContext } from '@modern-js/app-tools';
+export declare const routesForServer: ({ routes, }: {
+    routes: (NestedRouteForCli | PageRoute)[];
+}) => string;
+export declare const fileSystemRoutes: ({ routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks, }: {
+    routes: RouteLegacy[] | (NestedRouteForCli | PageRoute)[];
+    ssrMode?: SSRMode | undefined;
+    nestedRoutesEntry?: string | undefined;
+    entryName: string;
+    internalDirectory: string;
+    splitRouteChunks?: boolean | undefined;
+}) => Promise<string>;
+export declare function ssrLoaderCombinedModule(entrypoints: Entrypoint[], entrypoint: Entrypoint, config: AppNormalizedConfig<'shared'>, appContext: IAppContext): string | null;

package/dist/types/router/cli/code/utils.d.ts

@@ -0,0 +1,12 @@
+export declare const walkDirectory: (dir: string) => string[];
+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 getPathWithoutExt: (filename: string) => string;