@modern-js/runtime 2.41.0 → 2.42.1

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

@@ -1,3 +1,3 @@
 export { default as router } from './runtime';
 export { default } from './runtime';
-export * from './runtime';
+export * from './runtime';

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

@@ -1,2 +1,2 @@
 /// <reference types="react" />
-export declare const DefaultNotFound: () => JSX.Element;
+export declare const DefaultNotFound: () => JSX.Element;

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

@@ -1,2 +1,2 @@
 declare const _default: () => null;
-export default _default;
+export default _default;

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

@@ -4,6 +4,6 @@
  * it doesn't need to be hydrated in client side.
  */
 declare const DeferredDataScripts: (props?: {
-  nonce?: string;
+    nonce?: string;
 }) => JSX.Element | null;
-export default DeferredDataScripts;
+export default DeferredDataScripts;

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

@@ -18,11 +18,11 @@ export declare function composeEventHandlers<EventType extends React.SyntheticEv
  */
 type PrefetchBehavior = 'intent' | 'render' | 'none';
 export interface LinkProps extends RouterLinkProps {
-  prefetch?: PrefetchBehavior;
+    prefetch?: PrefetchBehavior;
 }
 export interface NavLinkProps extends RouterNavLinkProps {
-  prefetch?: PrefetchBehavior;
+    prefetch?: PrefetchBehavior;
 }
 declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
 declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefAttributes<HTMLAnchorElement>>;
-export { Link, NavLink };
+export { Link, NavLink };

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

@@ -1,2 +1,2 @@
 declare function installGlobals(): void;
-export { installGlobals };
+export { installGlobals };

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

@@ -1,2 +1,2 @@
 import { installGlobals } from '@remix-run/node';
-export { installGlobals };
+export { installGlobals };

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

@@ -1,2 +1,2 @@
 declare function installGlobals(): void;
-export { installGlobals };
+export { installGlobals };

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

@@ -1,3 +1,3 @@
 import { RouteObject } from '@modern-js/runtime-utils/router';
 declare const modifyRoutes: import("@modern-js/plugin").Waterfall<RouteObject[]>;
-export { modifyRoutes };
+export { modifyRoutes };

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

@@ -9,7 +9,7 @@ export * from './withRouter';
 export { Link, NavLink } from './PrefetchLink';
 export type { LinkProps, NavLinkProps } from './PrefetchLink';
 export declare const useRouteLoaderData: typeof useRouteData;
-export { createShouldRevalidate } from './shouldRevalidate';
+export { createShouldRevalidate, handleRouteModule, handleRouteModuleError, } from './routeModule';
 export type { LoaderFunction, LoaderFunctionArgs } from './types';
-export type { FormEncType, FormMethod, GetScrollRestorationKeyFunction, ParamKeyValuePair, SubmitOptions, URLSearchParamsInit, FetcherWithComponents, BrowserRouterProps, HashRouterProps, HistoryRouterProps, FormProps, ScrollRestorationProps, SubmitFunction, ActionFunction, ActionFunctionArgs, AwaitProps, unstable_Blocker, unstable_BlockerFunction, DataRouteMatch, DataRouteObject, Fetcher, Hash, IndexRouteObject, IndexRouteProps, JsonFunction, LayoutRouteProps, Location, MemoryRouterProps, NavigateFunction, NavigateOptions, NavigateProps, Navigation, Navigator, NonIndexRouteObject, OutletProps, Params, ParamParseKey, Path, PathMatch, Pathname, PathPattern, PathRouteProps, RedirectFunction, RelativeRoutingType, RouteMatch, RouteObject, RouteProps, RouterProps, RouterProviderProps, RoutesProps, Search, ShouldRevalidateFunction, To } from '@modern-js/runtime-utils/router';
-export { createBrowserRouter, createHashRouter, createMemoryRouter, RouterProvider, BrowserRouter, HashRouter, MemoryRouter, Router, Await, Form, Navigate, Outlet, Route, Routes, ScrollRestoration, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRoutes, useSearchParams, useSubmit, createRoutesFromChildren, createRoutesFromElements, createSearchParams, generatePath, isRouteErrorResponse, matchPath, matchRoutes, renderMatches, resolvePath, createPath, unstable_useBlocker, unstable_usePrompt, defer, json, redirect } from '@modern-js/runtime-utils/router';
+export type { FormEncType, FormMethod, GetScrollRestorationKeyFunction, ParamKeyValuePair, SubmitOptions, URLSearchParamsInit, FetcherWithComponents, BrowserRouterProps, HashRouterProps, HistoryRouterProps, FormProps, ScrollRestorationProps, SubmitFunction, ActionFunction, ActionFunctionArgs, AwaitProps, unstable_Blocker, unstable_BlockerFunction, DataRouteMatch, DataRouteObject, Fetcher, Hash, IndexRouteObject, IndexRouteProps, JsonFunction, LayoutRouteProps, Location, MemoryRouterProps, NavigateFunction, NavigateOptions, NavigateProps, Navigation, Navigator, NonIndexRouteObject, OutletProps, Params, ParamParseKey, Path, PathMatch, Pathname, PathPattern, PathRouteProps, RedirectFunction, RelativeRoutingType, RouteMatch, RouteObject, RouteProps, RouterProps, RouterProviderProps, RoutesProps, Search, ShouldRevalidateFunction, To, } from '@modern-js/runtime-utils/router';
+export { createBrowserRouter, createHashRouter, createMemoryRouter, RouterProvider, BrowserRouter, HashRouter, MemoryRouter, Router, Await, Form, Navigate, Outlet, Route, Routes, ScrollRestoration, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRoutes, useSearchParams, useSubmit, createRoutesFromChildren, createRoutesFromElements, createSearchParams, generatePath, isRouteErrorResponse, matchPath, matchRoutes, renderMatches, resolvePath, createPath, unstable_useBlocker, unstable_usePrompt, defer, json, redirect, } from '@modern-js/runtime-utils/router';

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

@@ -3,10 +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,
-  routesConfig,
-  createRoutes
-}: RouterConfig) => Plugin;
+export declare const routerPlugin: ({ serverBase, supportHtml5History, basename, routesConfig, createRoutes, }: RouterConfig) => Plugin;

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

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

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import type Module from 'module';
+import { ShouldRevalidateFunction } from '@modern-js/runtime-utils/remix-router';
+export declare const createShouldRevalidate: (routeId: string) => ShouldRevalidateFunction;
+export declare const handleRouteModule: (routeModule: Module, routeId: string) => Module;
+export declare const handleRouteModuleError: (error: Error) => null;

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

@@ -1 +1 @@
-export * from '@modern-js/runtime-utils/node/router';
+export * from '@modern-js/runtime-utils/node/router';

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

@@ -3,59 +3,59 @@ import type { RouteProps, RouteObject, Params } from '@modern-js/runtime-utils/r
 import { PageRoute, NestedRoute } from '@modern-js/types';
 import type { RequestContext } from '@modern-js/runtime-utils/node';
 declare global {
-  interface Window {
-    _SERVER_DATA?: {
-      router: {
-        baseUrl: string;
-        params: Record<string, string>;
-      };
-    };
-  }
+    interface Window {
+        _SERVER_DATA?: {
+            router: {
+                baseUrl: string;
+                params: Record<string, string>;
+            };
+        };
+    }
 }
 export type SingleRouteConfig = RouteProps & {
-  redirect?: string;
-  routes?: SingleRouteConfig[];
-  key?: string;
-  /**
-   * layout component
-   */
-  layout?: React.ComponentType;
-  /**
-   * component would be rendered when route macthed.
-   */
-  component?: React.ComponentType;
+    redirect?: string;
+    routes?: SingleRouteConfig[];
+    key?: string;
+    /**
+     * layout component
+     */
+    layout?: React.ComponentType;
+    /**
+     * component would be rendered when route macthed.
+     */
+    component?: React.ComponentType;
 };
 export type RouterConfig = {
-  mode?: 'react-router-5';
-  routesConfig: {
-    globalApp?: React.ComponentType<any>;
-    routes: (NestedRoute | PageRoute)[];
-  };
-  /**
-   * You should not use it
-   */
-  oldVersion?: boolean;
-  serverBase?: string[];
-  supportHtml5History?: boolean;
-  basename?: string;
-  createRoutes?: () => RouteObject[];
+    mode?: 'react-router-5';
+    routesConfig: {
+        globalApp?: React.ComponentType<any>;
+        routes: (NestedRoute | PageRoute)[];
+    };
+    /**
+     * You should not use it
+     */
+    oldVersion?: boolean;
+    serverBase?: string[];
+    supportHtml5History?: boolean;
+    basename?: string;
+    createRoutes?: () => RouteObject[];
 };
 export type Routes = RouterConfig['routesConfig']['routes'];
 export interface RouteManifest {
-  routeAssets: RouteAssets;
+    routeAssets: RouteAssets;
 }
 export interface RouteAssets {
-  [routeId: string]: {
-    chunkIds?: (string | number)[];
-    assets?: string[];
-  };
+    [routeId: string]: {
+        chunkIds?: (string | number)[];
+        assets?: string[];
+    };
 }
 interface DataFunctionArgs<D = any> {
-  request: Request;
-  params: Params;
-  context?: D;
+    request: Request;
+    params: Params;
+    context?: D;
 }
 export type LoaderFunctionArgs = DataFunctionArgs<RequestContext>;
 declare type DataFunctionValue = Response | NonNullable<unknown> | null;
 export type LoaderFunction = (args: LoaderFunctionArgs) => Promise<DataFunctionValue> | DataFunctionValue;
-export {};
+export {};

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

@@ -2,27 +2,17 @@ import React from 'react';
 import type { Reporter, NestedRoute, PageRoute, SSRMode } from '@modern-js/types';
 import { type StaticHandlerContext, type Router } from '@modern-js/runtime-utils/remix-router';
 import { RouterConfig } from './types';
-export declare function getRouteComponents(routes: (NestedRoute | PageRoute)[], {
-  globalApp,
-  ssrMode,
-  props,
-  reporter
-}: {
-  globalApp?: React.ComponentType<any>;
-  ssrMode?: SSRMode;
-  props?: Record<string, any>;
-  reporter?: Reporter;
+export declare function getRouteComponents(routes: (NestedRoute | PageRoute)[], { globalApp, ssrMode, props, reporter, }: {
+    globalApp?: React.ComponentType<any>;
+    ssrMode?: SSRMode;
+    props?: Record<string, any>;
+    reporter?: Reporter;
 }): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
-export declare function renderRoutes({
-  routesConfig,
-  props,
-  ssrMode,
-  reporter
-}: {
-  routesConfig: RouterConfig['routesConfig'];
-  props?: Record<string, any>;
-  ssrMode?: SSRMode;
-  reporter?: Reporter;
+export declare function renderRoutes({ routesConfig, props, ssrMode, reporter, }: {
+    routesConfig: RouterConfig['routesConfig'];
+    props?: Record<string, any>;
+    ssrMode?: SSRMode;
+    reporter?: Reporter;
 }): React.ReactElement<any, string | React.JSXElementConstructor<any>>[] | null;
 export declare function getLocation(serverContext: any): string;
 export declare const urlJoin: (...parts: string[]) => string;
@@ -36,4 +26,4 @@ export declare function serializeErrors(errors: StaticHandlerContext['errors']):
  * forked from https://github.com/remix-run/remix/blob/main/packages/remix-react/errors.ts
  * license at https://github.com/remix-run/remix/blob/main/LICENSE.md
  */
-export declare function deserializeErrors(errors: Router['state']['errors']): Router['state']['errors'];
+export declare function deserializeErrors(errors: Router['state']['errors']): Router['state']['errors'];

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

@@ -1,8 +1,8 @@
 import React from 'react';
 import { useLocation, useNavigate } from '@modern-js/runtime-utils/router';
 export interface WithRouterProps {
-  location: ReturnType<typeof useLocation>;
-  params: Record<string, string>;
-  navigate: ReturnType<typeof useNavigate>;
+    location: ReturnType<typeof useLocation>;
+    params: Record<string, string>;
+    navigate: ReturnType<typeof useNavigate>;
 }
-export declare const withRouter: <Props extends WithRouterProps>(Component: React.ComponentType<Props>) => (props: Omit<Props, keyof WithRouterProps>) => JSX.Element;
+export declare const withRouter: <Props extends WithRouterProps>(Component: React.ComponentType<Props>) => (props: Omit<Props, keyof WithRouterProps>) => JSX.Element;

package/dist/types/runtimeContext.d.ts

@@ -6,37 +6,37 @@ import { runtime } from './core/plugin';
 import { RouteManifest } from './router/runtime/types';
 import { SSRServerContext } from './ssr/serverRender/types';
 export interface BaseRuntimeContext {
-  initialData?: Record<string, unknown>;
-  loaderManager: ReturnType<typeof createLoaderManager>;
-  runner: ReturnType<typeof runtime.init>;
-  ssrContext?: SSRServerContext;
-  store?: Store;
-  routeManifest: RouteManifest;
-  routerContext?: StaticHandlerContext;
-  /**
-   * private method
-   */
-  remixRouter?: Router;
-  /**
-   * private
-   */
-  unstable_getBlockNavState?: () => boolean;
+    initialData?: Record<string, unknown>;
+    loaderManager: ReturnType<typeof createLoaderManager>;
+    runner: ReturnType<typeof runtime.init>;
+    ssrContext?: SSRServerContext;
+    store?: Store;
+    routeManifest: RouteManifest;
+    routerContext?: StaticHandlerContext;
+    /**
+     * private method
+     */
+    remixRouter?: Router;
+    /**
+     * private
+     */
+    unstable_getBlockNavState?: () => boolean;
 }
 export interface RuntimeContext extends BaseRuntimeContext {
-  [key: string]: any;
+    [key: string]: any;
 }
 export declare const RuntimeReactContext: import("react").Context<RuntimeContext>;
 export declare const ServerRouterContext: import("react").Context<any>;
 export interface BaseTRuntimeContext {
-  initialData?: Record<string, unknown>;
-  request?: SSRServerContext['request'];
-  response?: SSRServerContext['response'];
-  store?: Store;
-  router?: {
-    navigate: Router['navigate'];
-    location: RouterState['location'];
-  };
+    initialData?: Record<string, unknown>;
+    request?: SSRServerContext['request'];
+    response?: SSRServerContext['response'];
+    store?: Store;
+    router?: {
+        navigate: Router['navigate'];
+        location: RouterState['location'];
+    };
 }
 export interface TRuntimeContext extends BaseTRuntimeContext {
-  [key: string]: any;
-}
+    [key: string]: any;
+}

package/dist/types/ssr/cli/babel-plugin-ssr-loader-id.d.ts

@@ -1 +1 @@
-export {};
+export {};

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

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

package/dist/types/ssr/cli/loadable-bundler-plugin.d.ts

@@ -7,4 +7,4 @@
  * Copyright 2019 Greg Bergé
  * https://github.com/gregberge/loadable-components/blob/main/LICENSE
  */
-export {};
+export {};

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

@@ -1,11 +1,11 @@
 import type { Plugin } from '../core';
 import { RenderLevel, SSRServerContext, SSRPluginConfig } from './serverRender/types';
 declare module '../core' {
-  interface SSRContainer {
-    renderLevel: RenderLevel;
-    context?: SSRServerContext;
-  }
+    interface SSRContainer {
+        renderLevel: RenderLevel;
+        context?: SSRServerContext;
+    }
 }
 export declare const ssr: (config: SSRPluginConfig) => Plugin;
 export default ssr;
-export * from './react';
+export * from './react';

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

@@ -2,4 +2,4 @@ import type { Plugin } from '../core';
 import type { SSRPluginConfig } from './serverRender/types';
 export declare const ssr: (config?: SSRPluginConfig) => Plugin;
 export default ssr;
-export * from './react';
+export * from './react';

package/dist/types/ssr/prefetch.d.ts

@@ -3,14 +3,14 @@ import { LoaderResult } from '../core/loader/loaderManager';
 import { SSRPluginConfig } from './serverRender/types';
 import { SSRTracker } from './serverRender/tracker';
 declare const prefetch: (App: React.ComponentType<any>, context: RuntimeContext, config: SSRPluginConfig, tracker: SSRTracker) => Promise<{
-  initialData: Record<string, unknown> | undefined;
-  i18nData: any;
-  loadersData?: undefined;
-  storeState?: undefined;
+    initialData: Record<string, unknown> | undefined;
+    i18nData: any;
+    loadersData?: undefined;
+    storeState?: undefined;
 } | {
-  loadersData: Record<string, LoaderResult>;
-  initialData: Record<string, unknown> | undefined;
-  i18nData: any;
-  storeState: any;
+    loadersData: Record<string, LoaderResult>;
+    initialData: Record<string, unknown> | undefined;
+    i18nData: any;
+    storeState: any;
 }>;
-export default prefetch;
+export default prefetch;

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

@@ -1,2 +1,2 @@
 export { PreRender } from './prerender';
-export { NoSSR } from './nossr';
+export { NoSSR } from './nossr';

package/dist/types/ssr/react/nossr/index.d.ts

@@ -1,6 +1,6 @@
 import React, { ReactElement } from 'react';
 export declare const NoSSR: (props: React.PropsWithChildren<{
-  fallback?: ReactElement | string;
+    fallback?: ReactElement | string;
 }>) => React.FunctionComponentElement<{
-  children?: React.ReactNode;
-}>;
+    children?: React.ReactNode;
+}>;

package/dist/types/ssr/react/prerender/index.d.ts

@@ -1 +1 @@
-export declare const PreRender: any;
+export declare const PreRender: any;

package/dist/types/ssr/react/prerender/type.d.ts

@@ -1,29 +1,29 @@
 export type SprProps = {
-  interval: number;
-  staleLimit: number | boolean;
-  level: number;
-  includes: MetaKeyMap | null;
-  excludes: MetaKeyMap | null;
-  fallback: boolean;
-  matches: MetaKeyMatch | null;
+    interval: number;
+    staleLimit: number | boolean;
+    level: number;
+    includes: MetaKeyMap | null;
+    excludes: MetaKeyMap | null;
+    fallback: boolean;
+    matches: MetaKeyMatch | null;
 };
 export type GeneralizedProps = SprProps & {
-  [propName: string]: any;
+    [propName: string]: any;
 };
 export type SprConstructor = {
-  config: () => SprProps;
+    config: () => SprProps;
 };
 export type MetaKeyMap = {
-  header?: string[];
-  query?: string[];
+    header?: string[];
+    query?: string[];
 };
 type MatchMap = {
-  [propName: string]: {
-    [propName: string]: string;
-  };
+    [propName: string]: {
+        [propName: string]: string;
+    };
 };
 export type MetaKeyMatch = {
-  header?: MatchMap;
-  query?: MatchMap;
+    header?: MatchMap;
+    query?: MatchMap;
 };
-export {};
+export {};

package/dist/types/ssr/react/prerender/util.d.ts

@@ -3,4 +3,4 @@ export declare const getInnermostProperty: (propsList: GeneralizedProps[], propN
 export declare const getOutermostProperty: (propsList: GeneralizedProps[], propName: string) => any;
 export declare const aggKeysFromPropsList: (propsList: GeneralizedProps[], propName: string) => MetaKeyMap;
 export declare const aggMatchesFromPropsList: (propsList: GeneralizedProps[], propName: string) => MetaKeyMatch;
-export declare function exist(target: any): boolean;
+export declare function exist(target: any): boolean;

package/dist/types/ssr/react/withCallback/index.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
 export declare const WithCallback: React.FC<{
-  callback: () => void;
-  children: React.ReactElement;
-}>;
+    callback: () => void;
+    children: React.ReactElement;
+}>;

package/dist/types/ssr/serverRender/helmet.d.ts

@@ -1,2 +1,2 @@
 import { HelmetData } from 'react-helmet';
-export default function helmet(content: string, helmetData: HelmetData): string;
+export default function helmet(content: string, helmetData: HelmetData): string;

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

@@ -1,2 +1,2 @@
 import { ServerRenderOptions } from './types';
-export default function serverRender(options: ServerRenderOptions): Promise<any>;
+export default function serverRender(options: ServerRenderOptions): Promise<any>;

package/dist/types/ssr/serverRender/renderToStream/buildTemplate.after.d.ts

@@ -1,7 +1,7 @@
 import { RenderLevel, RuntimeContext } from '../types';
 type BuildShellAfterTemplateOptions = {
-  context: RuntimeContext;
-  renderLevel: RenderLevel;
+    context: RuntimeContext;
+    renderLevel: RenderLevel;
 };
 export declare function buildShellAfterTemplate(afterAppTemplate: string, options: BuildShellAfterTemplateOptions): string;
-export {};
+export {};

package/dist/types/ssr/serverRender/renderToStream/buildTemplate.share.d.ts

@@ -1,3 +1,3 @@
 export declare const HEAD_REG_EXP: RegExp;
 export type BuildTemplateCb = (headTemplate: string) => string;
-export declare function buildTemplate(template: string, callbacks: BuildTemplateCb[]): string;
+export declare function buildTemplate(template: string, callbacks: BuildTemplateCb[]): string;

package/dist/types/ssr/serverRender/renderToStream/bulidTemplate.before.d.ts

@@ -1,2 +1,2 @@
 import { RuntimeContext } from '../types';
-export declare function buildShellBeforeTemplate(beforeAppTemplate: string, context: RuntimeContext): string;
+export declare function buildShellBeforeTemplate(beforeAppTemplate: string, context: RuntimeContext): string;

package/dist/types/ssr/serverRender/renderToStream/index.d.ts

@@ -1,6 +1,3 @@
 /// <reference types="node" />
 import { ServerRenderOptions } from '../types';
-export declare const render: ({
-  App,
-  context
-}: ServerRenderOptions) => Promise<import("./renderToPipe").Pipe<import("stream").Writable>>;
+export declare const render: ({ App, context }: ServerRenderOptions) => Promise<import("./renderToPipe").Pipe<import("stream").Writable>>;

package/dist/types/ssr/serverRender/renderToStream/renderToPipe.d.ts

@@ -5,4 +5,4 @@ import type { RenderToPipeableStreamOptions } from 'react-dom/server';
 import { RuntimeContext } from '../types';
 export type Pipe<T extends Writable> = (output: T) => Promise<T | string>;
 declare function renderToPipe(rootElement: React.ReactElement, context: RuntimeContext, options?: RenderToPipeableStreamOptions): Pipe<Writable>;
-export default renderToPipe;
+export default renderToPipe;

package/dist/types/ssr/serverRender/renderToStream/renderToPipe.worker.d.ts

@@ -5,4 +5,4 @@ import type { RenderToReadableStreamOptions } from 'react-dom/server';
 import { RuntimeContext } from '../types';
 export type Pipe<T extends Writable> = (output: T) => Promise<T | string>;
 declare function renderToPipe(rootElement: React.ReactElement, context: RuntimeContext, options?: RenderToReadableStreamOptions): Promise<string | ReadableStream<any>>;
-export default renderToPipe;
+export default renderToPipe;

package/dist/types/ssr/serverRender/renderToStream/template.d.ts

@@ -1,6 +1,6 @@
 import { RenderLevel, RuntimeContext } from '../types';
 export type InjectTemplate = {
-  shellBefore: string;
-  shellAfter: string;
+    shellBefore: string;
+    shellAfter: string;
 };
-export declare const getTemplates: (context: RuntimeContext, renderLevel: RenderLevel) => InjectTemplate;
+export declare const getTemplates: (context: RuntimeContext, renderLevel: RenderLevel) => InjectTemplate;

package/dist/types/ssr/serverRender/renderToString/buildHtml.d.ts

@@ -3,4 +3,4 @@ export declare function buildHtml(template: string, callbacks: BuildHtmlCb[]): s
 export declare function createReplaceHtml(html: string): BuildHtmlCb;
 export declare function createReplaceSSRDataScript(data: string): BuildHtmlCb;
 export declare function createReplaceChunkJs(js: string): BuildHtmlCb;
-export declare function createReplaceChunkCss(css: string): BuildHtmlCb;
+export declare function createReplaceChunkCss(css: string): BuildHtmlCb;

package/dist/types/ssr/serverRender/renderToString/entry.d.ts

@@ -2,25 +2,25 @@ import { RuntimeContext, ModernSSRReactComponent, SSRPluginConfig, SSRServerCont
 import { SSRTracker } from '../tracker';
 import { RenderResult } from './type';
 type EntryOptions = {
-  ctx: SSRServerContext;
-  App: ModernSSRReactComponent;
-  config: SSRPluginConfig;
+    ctx: SSRServerContext;
+    App: ModernSSRReactComponent;
+    config: SSRPluginConfig;
 };
 export default class Entry {
-  entryName: string;
-  result: RenderResult;
-  metrics: SSRServerContext['metrics'];
-  tracker: SSRTracker;
-  private readonly template;
-  private readonly App;
-  private readonly pluginConfig;
-  private readonly htmlModifiers;
-  private readonly nonce?;
-  private readonly routeManifest?;
-  constructor(options: EntryOptions);
-  renderToHtml(context: RuntimeContext): Promise<string>;
-  private prefetch;
-  private renderToString;
-  private getSSRDataScript;
+    entryName: string;
+    result: RenderResult;
+    metrics: SSRServerContext['metrics'];
+    tracker: SSRTracker;
+    private readonly template;
+    private readonly App;
+    private readonly pluginConfig;
+    private readonly htmlModifiers;
+    private readonly nonce?;
+    private readonly routeManifest?;
+    constructor(options: EntryOptions);
+    renderToHtml(context: RuntimeContext): Promise<string>;
+    private prefetch;
+    private renderToString;
+    private getSSRDataScript;
 }
-export {};
+export {};

package/dist/types/ssr/serverRender/renderToString/index.d.ts

@@ -1,6 +1,2 @@
 import { ServerRenderOptions } from '../types';
-export declare const render: ({
-  App,
-  context,
-  config
-}: ServerRenderOptions) => Promise<string>;
+export declare const render: ({ App, context, config, }: ServerRenderOptions) => Promise<string>;