@modern-js/runtime 2.54.6 → 2.55.0

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

@@ -10,17 +10,7 @@ declare const runtimeHooks: {
     }, 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>;
+    }, unknown>;
     pickContext: import("@modern-js/plugin").Pipeline<{
         context: RuntimeContext;
         pickedContext: TRuntimeContext;
@@ -37,17 +27,7 @@ export declare const createRuntime: () => import("@modern-js/plugin").Manager<{
     }, 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>;
+    }, unknown>;
     pickContext: import("@modern-js/plugin").Pipeline<{
         context: RuntimeContext;
         pickedContext: TRuntimeContext;
@@ -60,17 +40,7 @@ export declare const runtime: import("@modern-js/plugin").Manager<{
     }, 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>;
+    }, unknown>;
     pickContext: import("@modern-js/plugin").Pipeline<{
         context: RuntimeContext;
         pickedContext: TRuntimeContext;

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

@@ -11,19 +11,10 @@ export declare function registerPlugin(internalPlugins: Plugin[], runtimeConfig?
     }, 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>;
+    }, unknown>;
     pickContext: import("@modern-js/plugin").Pipeline<{
         context: import("..").RuntimeContext;
         pickedContext: import("../context/runtime").TRuntimeContext;
     }, import("../context/runtime").TRuntimeContext>;
 }>;
+export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): any;

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

@@ -8,17 +8,7 @@ export declare function getGlobalRunner(): import("@modern-js/plugin").ToRunners
     }, 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>;
+    }, unknown>;
     pickContext: import("@modern-js/plugin").Pipeline<{
         context: import("..").RuntimeContext;
         pickedContext: import("../context/runtime").TRuntimeContext;

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

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare function createRoot(UserApp?: React.ComponentType | null, config?: {
+    router: {
+        basename: string;
+    };
+}): React.ComponentType<any>;

package/dist/types/core/server/helmet.d.ts

@@ -0,0 +1,3 @@
+import { HelmetData } from 'react-helmet';
+export declare function createReplaceHelemt(helmetData?: HelmetData): (template: string) => string;
+export declare function helmetReplace(content: string, helmetData: HelmetData): string;

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

@@ -0,0 +1,4 @@
+import { Plugin } from '../plugin';
+export { PreRender, NoSSR } from './react';
+export declare const ssr: (_config: any) => Plugin;
+export default ssr;

package/dist/types/core/server/requestHandler.d.ts

@@ -0,0 +1,11 @@
+import { RequestHandler, RequestHandlerOptions } from '@modern-js/app-tools';
+import React from 'react';
+import { RuntimeContext } from '../context';
+export type { RequestHandlerConfig as HandleRequestConfig } from '@modern-js/app-tools';
+export type HandleRequestOptions = Exclude<RequestHandlerOptions, 'staticGenerate'> & {
+    runtimeContext: RuntimeContext;
+};
+export type HandleRequest = (request: Request, ServerRoot: React.ComponentType, // App, routes,
+options: HandleRequestOptions) => Promise<Response>;
+export type CreateRequestHandler = (handleRequest: HandleRequest) => Promise<RequestHandler>;
+export declare const createRequestHandler: CreateRequestHandler;

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

@@ -0,0 +1,4 @@
+export { renderString } from './string';
+export { renderStreaming } from './stream';
+export { createRequestHandler, type HandleRequest, type HandleRequestOptions, type HandleRequestConfig, type CreateRequestHandler, } from './requestHandler';
+export type { RenderStreaming, RenderString, RenderOptions } from './shared';

package/dist/types/core/server/shared.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { ServerUserConfig } from '@modern-js/app-tools';
+import type { HandleRequestOptions } from './requestHandler';
+export type RenderOptions = HandleRequestOptions;
+export type SSRConfig = NonNullable<ServerUserConfig['ssr']>;
+export type RenderStreaming = (request: Request, serverRoot: React.ReactElement, optinos: RenderOptions) => Promise<ReadableStream>;
+export type RenderString = (request: Request, serverRoot: React.ReactElement, optinos: RenderOptions) => Promise<string>;
+export type BuildHtmlCb = (template: string) => string | Promise<string>;
+export declare function buildHtml(template: string, callbacks: BuildHtmlCb[]): Promise<string>;

package/dist/types/core/server/stream/afterTemplate.d.ts

@@ -0,0 +1,12 @@
+import { SSRConfig } from '../shared';
+import { RenderLevel } from '../../constants';
+import { HandleRequestConfig } from '../requestHandler';
+import { RuntimeContext } from '../../context';
+export type BuildShellAfterTemplateOptions = {
+    runtimeContext: RuntimeContext;
+    renderLevel: RenderLevel;
+    ssrConfig: SSRConfig;
+    request: Request;
+    config: HandleRequestConfig;
+};
+export declare function buildShellAfterTemplate(afterAppTemplate: string, options: BuildShellAfterTemplateOptions): Promise<string>;

package/dist/types/core/server/stream/beforeTemplate.d.ts

@@ -0,0 +1,8 @@
+import { RuntimeContext } from '../../context';
+import { HandleRequestConfig } from '../requestHandler';
+export interface BuildShellBeforeTemplateOptions {
+    runtimeContext: RuntimeContext;
+    config: HandleRequestConfig;
+    styledComponentsStyleTags?: string;
+}
+export declare function buildShellBeforeTemplate(beforeAppTemplate: string, options: BuildShellBeforeTemplateOptions): Promise<string>;

package/dist/types/core/server/stream/createReadableStream.d.ts

@@ -0,0 +1,2 @@
+import { CreateReadableStreamFromElement } from './shared';
+export declare const createReadableStreamFromElement: CreateReadableStreamFromElement;

package/dist/types/core/server/stream/createReadableStream.worker.d.ts

@@ -0,0 +1,2 @@
+import { CreateReadableStreamFromElement } from './shared';
+export declare const createReadableStreamFromElement: CreateReadableStreamFromElement;

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

@@ -0,0 +1 @@
+export declare const renderStreaming: import("../shared").RenderStreaming;

package/dist/types/core/server/stream/shared.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { RuntimeContext } from '../../context';
+import { HandleRequestConfig } from '../requestHandler';
+import type { RenderStreaming, SSRConfig } from '../shared';
+export type CreateReadableStreamFromElementOptions = {
+    runtimeContext: RuntimeContext;
+    config: HandleRequestConfig;
+    ssrConfig: SSRConfig;
+    htmlTemplate: string;
+    onShellReady?: () => void;
+    onShellError?: (error: unknown) => void;
+    onAllReady?: () => void;
+    onError?: (error: unknown) => void;
+};
+export type CreateReadableStreamFromElement = (request: Request, rootElement: React.ReactElement, options: CreateReadableStreamFromElementOptions) => Promise<ReadableStream<Uint8Array>>;
+export declare enum ShellChunkStatus {
+    START = 0,
+    FINISH = 1
+}
+export declare function encodeForWebStream(thing: unknown): unknown;
+export declare function getReadableStreamFromString(content: string): ReadableStream;
+export declare function createRenderStreaming(createReadableStreamFromElement: CreateReadableStreamFromElement): RenderStreaming;

package/dist/types/core/server/stream/template.d.ts

@@ -0,0 +1,9 @@
+import { type BuildShellBeforeTemplateOptions } from './beforeTemplate';
+import { type BuildShellAfterTemplateOptions } from './afterTemplate';
+export type InjectTemplate = {
+    shellBefore: string;
+    shellAfter: string;
+};
+type GetTemplatesOptions = BuildShellAfterTemplateOptions & BuildShellBeforeTemplateOptions;
+export declare const getTemplates: (htmlTemplate: string, options: GetTemplatesOptions) => Promise<InjectTemplate>;
+export {};

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

@@ -0,0 +1,2 @@
+import { RenderString } from '../shared';
+export declare const renderString: RenderString;

package/dist/types/core/server/string/loadable.d.ts

@@ -0,0 +1,35 @@
+import { ReactElement } from 'react';
+import type { Collector, ChunkSet } from './types';
+declare module '@loadable/server' {
+    interface ChunkExtractor {
+        chunks: Chunk;
+        getChunkAssets: (chunks: Chunk) => Chunk[];
+    }
+}
+export interface LoadableCollectorOptions {
+    nonce?: string;
+    stats?: Record<string, any>;
+    routeManifest?: Record<string, any>;
+    template: string;
+    entryName: string;
+    chunkSet: ChunkSet;
+    config: LoadableCollectorConfig;
+}
+export interface LoadableCollectorConfig {
+    scriptLoading?: 'defer' | 'blocking' | 'module' | 'async';
+    enableInlineStyles?: boolean | RegExp;
+    enableInlineScripts?: boolean | RegExp;
+    crossorigin?: boolean | 'anonymous' | 'use-credentials';
+}
+export declare class LoadableCollector implements Collector {
+    private options;
+    private extractor?;
+    constructor(options: LoadableCollectorOptions);
+    private get existsAssets();
+    collect(comopnent: ReactElement): ReactElement;
+    effect(): Promise<void>;
+    private emitLoadableScripts;
+    private emitScriptAssets;
+    private emitStyleAssets;
+    private generateAttributes;
+}

package/dist/types/core/server/string/prefetch.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { LoaderResult } from '../../loader/loaderManager';
+import { HandleRequestOptions } from '../requestHandler';
+import { Tracer } from '../tracer';
+export declare const prefetch: (App: React.ReactElement, request: Request, options: HandleRequestOptions, { onError, onTiming }: Tracer) => Promise<{
+    initialData: Record<string, unknown> | undefined;
+    i18nData: any;
+    loadersData?: undefined;
+    storeState?: undefined;
+} | {
+    loadersData: Record<string, LoaderResult>;
+    initialData: Record<string, unknown> | undefined;
+    i18nData: any;
+    storeState: any;
+}>;

package/dist/types/core/server/string/ssrData.d.ts

@@ -0,0 +1,18 @@
+import { StaticHandlerContext } from '@modern-js/runtime-utils/remix-router';
+import { SSRConfig } from '../shared';
+import { SSRServerContext } from '../../types';
+import { Collector, ChunkSet } from './types';
+export interface SSRDataCreatorOptions {
+    request: Request;
+    prefetchData: Record<string, any>;
+    chunkSet: ChunkSet;
+    ssrContext: SSRServerContext;
+    ssrConfig?: SSRConfig;
+    routerContext?: StaticHandlerContext;
+    nonce?: string;
+}
+export declare class SSRDataCollector implements Collector {
+    #private;
+    constructor(options: SSRDataCreatorOptions);
+    effect(): void;
+}

package/dist/types/core/server/string/styledComponent.d.ts

@@ -0,0 +1,11 @@
+import { ServerStyleSheet } from 'styled-components';
+import { ReactElement } from 'react';
+import type { ChunkSet, Collector } from './types';
+export declare class StyledCollector implements Collector {
+    #private;
+    constructor(chunkSet: ChunkSet);
+    collect(comopnent: ReactElement): ReactElement<{
+        sheet: ServerStyleSheet;
+    }, string | import("react").JSXElementConstructor<any>>;
+    effect(): void;
+}

package/dist/types/core/server/string/types.d.ts

@@ -0,0 +1,12 @@
+import { ReactElement } from 'react';
+import { RenderLevel } from '../../constants';
+export interface Collector {
+    collect?: (comopnent: ReactElement) => ReactElement;
+    effect: () => void | Promise<void>;
+}
+export type ChunkSet = {
+    renderLevel: RenderLevel;
+    ssrScripts: string;
+    jsChunk: string;
+    cssChunk: string;
+};

package/dist/types/core/server/tracer.d.ts

@@ -0,0 +1,21 @@
+export declare enum SSRTimings {
+    PRERENDER = "ssr-prerender",
+    RENDER_HTML = "ssr-render-html",
+    RENDER_SHELL = "ssr-render-shell",
+    USE_LOADER = "use-loader"
+}
+export declare enum SSRErrors {
+    PRERENDER = "App Prerender",
+    USE_LOADER = "App run useLoader",
+    RENDER_HTML = "App Render To HTML",
+    RENDER_STREAM = "An error occurs during streaming SSR",
+    RENDER_SHELL = "An error occurs during streaming render shell"
+}
+export type Tracer = {
+    onError: OnError;
+    onTiming: OnTiming;
+};
+export type OnError = (key: SSRErrors, e: unknown) => void;
+export declare function createOnError(onError?: (e: unknown) => void): OnError;
+export type OnTiming = (key: SSRTimings, cost: number) => void;
+export declare function createOnTiming(onTiming?: (name: string, dur: number) => void): OnTiming;

package/dist/types/core/server/utils.d.ts

@@ -0,0 +1,19 @@
+import { StaticHandlerContext } from '@modern-js/runtime-utils/remix-router';
+import { ServerUserConfig } from '@modern-js/app-tools';
+import { SSRConfig } from './shared';
+export declare function attributesToString(attributes: Record<string, any>): string;
+/**
+ * @param source
+ * @param searchValue
+ * @param replaceValue
+ * @returns
+ */
+export declare function safeReplace(source: string, searchValue: string | RegExp, replaceValue: string): string;
+export declare function checkIsNode(): boolean;
+/**
+ * forked from https://github.com/remix-run/remix/blob/main/packages/remix-server-runtime/errors.ts
+ * license at https://github.com/remix-run/remix/blob/main/LICENSE.md
+ */
+export declare function serializeErrors(errors: StaticHandlerContext['errors']): StaticHandlerContext['errors'];
+export declare function getSSRConfigByEntry(entryName: string, ssr?: ServerUserConfig['ssr'], ssrByEntries?: ServerUserConfig['ssrByEntries'], staticGenerate?: boolean): import("@modern-js/app-tools").SSR;
+export declare function getSSRMode(ssrConfig?: SSRConfig): 'string' | 'stream' | false;

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

@@ -1,4 +1,6 @@
+import { BaseSSRServerContext } from '@modern-js/types';
 import type { LoaderResult } from './loader/loaderManager';
+import type { RenderLevel } from './constants';
 declare global {
     interface Window {
         _SSR_DATA?: SSRContainer;
@@ -6,9 +8,10 @@ declare global {
     }
 }
 export interface SSRData {
-    loadersData: Record<string, LoaderResult | undefined>;
+    loadersData?: Record<string, LoaderResult | undefined>;
     initialData?: Record<string, unknown>;
     storeState?: any;
+    [props: string]: any;
 }
 export interface RouteData {
     [routeId: string]: any;
@@ -17,6 +20,37 @@ export interface RouterSSRData {
     loaderData: RouteData;
     errors: RouteData | null;
 }
+export type SSRMode = 'string' | 'stream';
 export interface SSRContainer {
+    renderLevel: RenderLevel;
+    mode: SSRMode;
     data?: SSRData;
+    context?: {
+        request: {
+            params: Record<string, any>;
+            query: Record<string, string>;
+            pathname: string;
+            host: string;
+            url: string;
+            headers?: Record<string, string | undefined>;
+        };
+        reporter?: {
+            sessionId?: string;
+        };
+    };
 }
+type BuildHtmlCb = (tempalte: string) => string;
+export type SSRServerContext = Pick<BaseSSRServerContext, 'redirection' | 'response' | 'nonce' | 'mode' | 'loaderContext' | 'reporter' | 'logger' | 'metrics' | 'routeManifest'> & {
+    request: BaseSSRServerContext['request'] & {
+        baseUrl: string;
+        userAgent: string;
+        cookie: string;
+        cookieMap: Record<string, string>;
+        raw: Request;
+    };
+    htmlModifiers: BuildHtmlCb[];
+    loaderFailureMode?: 'clientRender' | 'errorBoundary';
+    onError?: (e: unknown) => void;
+    onTiming?: (name: string, dur: number) => void;
+};
+export {};

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
 import type { StateConfig } from './state';
 import type { RouterConfig } from './router';
 export type { Plugin } from './core';
-export type { AppConfig } from './common';
+export type { AppConfig, RuntimeConfig } from './common';
 export { isBrowser } from './common';
 export type { BaseRuntimeContext, RuntimeContext, BaseTRuntimeContext, } from './core/context/runtime';
 export type { RuntimeUserConfig } from './config';

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

@@ -1,6 +1,5 @@
 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[]>;
-}>;
+import { AppNormalizedConfig, AppTools } from '@modern-js/app-tools';
+export declare const generateCode: (appContext: IAppContext, config: AppNormalizedConfig<'shared'>, entrypoints: Entrypoint[], api: PluginAPI<AppTools<'shared'>>) => Promise<void>;
+export declare function generatorRegisterCode(internalDirectory: string, entryName: string, code: string): void;

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

@@ -3,7 +3,8 @@ 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, }: {
+export declare const fileSystemRoutes: ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks, }: {
+    metaName: string;
     routes: RouteLegacy[] | (NestedRouteForCli | PageRoute)[];
     ssrMode?: SSRMode | undefined;
     nestedRoutesEntry?: string | undefined;
@@ -12,3 +13,10 @@ export declare const fileSystemRoutes: ({ routes, ssrMode, nestedRoutesEntry, en
     splitRouteChunks?: boolean | undefined;
 }) => Promise<string>;
 export declare function ssrLoaderCombinedModule(entrypoints: Entrypoint[], entrypoint: Entrypoint, config: AppNormalizedConfig<'shared'>, appContext: IAppContext): string | null;
+export declare const runtimeGlobalContext: ({ metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, }: {
+    metaName: string;
+    srcDirectory: string;
+    nestedRoutesEntry?: string | undefined;
+    internalSrcAlias: string;
+    globalApp?: string | false | undefined;
+}) => Promise<string>;

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

@@ -10,6 +10,8 @@ export declare const FILE_SYSTEM_ROUTES_INDEX = "index";
 export declare const FILE_SYSTEM_ROUTES_IGNORED_REGEX: RegExp;
 export declare const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP: RegExp;
 export declare const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = "internal_components";
+export declare const APP_CONFIG_NAME = "config";
+export declare const APP_INIT_EXPORTED = "init";
 export declare const NESTED_ROUTE: {
     LAYOUT_FILE: string;
     LAYOUT_CONFIG_FILE: string;

package/dist/types/router/cli/handler.d.ts

@@ -2,4 +2,5 @@ import { Entrypoint } from '@modern-js/types';
 import { PluginAPI } from '@modern-js/core';
 import { AppTools } from '@modern-js/app-tools';
 export declare function handleModifyEntrypoints(api: PluginAPI<AppTools<'shared'>>, entrypoints: Entrypoint[]): Promise<Entrypoint[]>;
+export declare function handleGeneratorEntryCode(api: PluginAPI<AppTools<'shared'>>, entrypoints: Entrypoint[]): Promise<Entrypoint[]>;
 export declare function handleFileChange(api: PluginAPI<AppTools<'shared'>>, e: any): Promise<void>;

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

@@ -4,6 +4,7 @@ import type { SingleRouteConfig, RouterConfig } from './types';
 export * from '@modern-js/runtime-utils/router';
 export type { SingleRouteConfig, RouterConfig };
 export { renderRoutes } from './utils';
+export { routerPlugin };
 export default routerPlugin;
 export { modifyRoutes } from './plugin';
 export * from './withRouter';

package/dist/types/router/runtime/plugin.d.ts

@@ -3,4 +3,4 @@ import type { RouterConfig, Routes } from './types';
 export declare let finalRouteConfig: RouterConfig['routesConfig'];
 export declare let beforeCreateRouter: boolean;
 export declare function modifyRoutes(modifyFunction: (routes: Routes) => Routes): void;
-export declare const routerPlugin: ({ serverBase, supportHtml5History, basename, originalBaseUrl, routesConfig, createRoutes, }: RouterConfig) => Plugin;
+export declare const routerPlugin: ({ serverBase, supportHtml5History, basename, routesConfig, createRoutes, }: RouterConfig) => Plugin;

package/dist/types/router/runtime/plugin.node.d.ts

@@ -1,6 +1,6 @@
 import type { Plugin } from '../../core';
-import { SSRServerContext } from '../../ssr/serverRender/types';
+import { SSRServerContext } from '../../core/types';
 import type { RouterConfig } from './types';
 export declare function createFetchHeaders(requestHeaders: SSRServerContext['request']['headers']): Headers;
-export declare const routerPlugin: ({ basename, originalBaseUrl, routesConfig, createRoutes, }: RouterConfig) => Plugin;
+export declare const routerPlugin: ({ basename, routesConfig, createRoutes, }: RouterConfig) => Plugin;
 export declare const modifyRoutes: () => void;

package/dist/types/router/runtime/types.d.ts

@@ -29,7 +29,7 @@ export type RouterConfig = {
     mode?: 'react-router-5';
     routesConfig: {
         globalApp?: React.ComponentType<any>;
-        routes: (NestedRoute | PageRoute)[];
+        routes?: (NestedRoute | PageRoute)[];
     };
     /**
      * You should not use it
@@ -37,7 +37,6 @@ export type RouterConfig = {
     oldVersion?: boolean;
     serverBase?: string[];
     supportHtml5History?: boolean;
-    originalBaseUrl?: string;
     basename?: string;
     createRoutes?: () => RouteObject[];
 };

package/dist/types/state/runtime/plugin.d.ts

@@ -6,6 +6,6 @@ type StateExtraType = {
     models: Array<Model>;
 };
 export type StateConfig = Partial<Record<StatePluginType, boolean> & StateExtraType>;
-declare const state: (config: StateConfig) => Plugin;
-export default state;
+export declare const statePlugin: (config: StateConfig) => Plugin;
+export default statePlugin;
 export * from '../plugins';