@modern-js/runtime 1.21.5 → 2.0.0-beta.1

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

@@ -1,6 +1,6 @@
 import { routerPlugin } from './plugin';
-import type { SingleRouteConfig, HistoryConfig, RouterConfig } from './plugin';
-export type { SingleRouteConfig, HistoryConfig, RouterConfig };
+import type { SingleRouteConfig, RouterConfig } from './types';
+export type { SingleRouteConfig, RouterConfig };
 export default routerPlugin;
 export * from 'react-router-dom';
-export * from 'history';
+export * from './withRouter';

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

@@ -1,51 +1,8 @@
-import React from 'react';
-import { History, BrowserHistoryBuildOptions, HashHistoryBuildOptions } from 'history';
-import { RouteProps } from 'react-router-dom';
 import type { Plugin } from '../../core';
-declare global {
-  interface Window {
-    _SERVER_DATA?: {
-      router: {
-        baseUrl: string;
-        params: Record<string, string>;
-      };
-    };
-  }
-}
-export declare type SingleRouteConfig = RouteProps & {
-  redirect?: string;
-  routes?: SingleRouteConfig[];
-  key?: string;
-  /**
-   * layout component
-   */
-
-  layout?: React.ComponentType;
-  /**
-   * component would be rendered when route macthed.
-   */
-
-  component?: React.ComponentType;
-};
-export declare type HistoryConfig = {
-  supportHtml5History: true;
-  historyOptions: BrowserHistoryBuildOptions;
-} | {
-  supportHtml5History: false;
-  historyOptions: HashHistoryBuildOptions;
-};
-export declare type RouterConfig = Partial<HistoryConfig> & {
-  routesConfig?: {
-    globalApp?: React.ComponentType<any>;
-    routes?: SingleRouteConfig[];
-  };
-  history?: History;
-  serverBase?: string[];
-};
+import type { RouterConfig } from './types';
 export declare const routerPlugin: ({
   serverBase,
-  history: customHistory,
   supportHtml5History,
   routesConfig,
-  historyOptions
+  createRoutes
 }: RouterConfig) => Plugin;

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

@@ -0,0 +1,8 @@
+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: ({
+  routesConfig,
+  createRoutes
+}: RouterConfig) => Plugin;

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { NestedRoute } from '@modern-js/types';
+interface IProps {
+  children: React.ReactNode;
+  routes: NestedRoute[];
+}
+export declare function RootLayout(props: IProps): JSX.Element;
+export {};

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

@@ -0,0 +1,22 @@
+import { Location, Params } from 'react-router-dom';
+import type { NestedRoute } from '@modern-js/types';
+interface RouteAssets {
+  [routeId: string]: {
+    chunkIds?: (string | number)[];
+    assets?: string[];
+  };
+}
+interface RouteManifest {
+  routeAssets: RouteAssets;
+  enableFetchParallel?: boolean;
+  enableLogging?: boolean;
+}
+export interface RouteMatch<Route> {
+  params: Params;
+  pathname: string;
+  route: Route;
+}
+export declare function handleLoad(routes: NestedRoute[], location: Location, routeManifest: RouteManifest): void;
+export declare function matchClientRoutes(routes: NestedRoute[], location: Location): RouteMatch<NestedRoute>[];
+export declare function loadRouteModule(route: NestedRoute, routeAssets: RouteAssets): Promise<string[] | void>;
+export {};

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

@@ -0,0 +1,36 @@
+/// <reference types="react" />
+import type { RouteProps, RouteObject } from 'react-router-dom';
+import { PageRoute, NestedRoute } from '@modern-js/types';
+declare global {
+  interface Window {
+    _SERVER_DATA?: {
+      router: {
+        baseUrl: string;
+        params: Record<string, string>;
+      };
+    };
+  }
+}
+export declare type SingleRouteConfig = RouteProps & {
+  redirect?: string;
+  routes?: SingleRouteConfig[];
+  key?: string;
+  /**
+   * layout component
+   */
+  layout?: React.ComponentType;
+  /**
+   * component would be rendered when route macthed.
+   */
+  component?: React.ComponentType;
+};
+export declare type RouterConfig = {
+  legacy?: boolean;
+  routesConfig: {
+    globalApp?: React.ComponentType<any>;
+    routes: (NestedRoute | PageRoute)[];
+  };
+  serverBase?: string[];
+  supportHtml5History?: boolean;
+  createRoutes?: () => RouteObject[];
+};

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

@@ -1,5 +1,8 @@
-import { RouterConfig } from './plugin';
-export declare function renderRoutes(routesConfig: RouterConfig['routesConfig'], extraProps?: any): JSX.Element;
+import React from 'react';
+import type { NestedRoute, PageRoute } from '@modern-js/types';
+import { RouterConfig } from './types';
+export declare function getRouteComponents(routes: (NestedRoute | PageRoute)[], globalApp?: React.ComponentType<any>): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+export declare function renderRoutes(routesConfig: RouterConfig['routesConfig']): React.ReactElement<any, string | React.JSXElementConstructor<any>>[] | null;
 export declare function getLocation(serverContext: any): string;
 export declare const urlJoin: (...parts: string[]) => string;
 export declare function standardSlash(str: string): string;

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import { useLocation, useNavigate } from 'react-router-dom';
+export interface WithRouterProps {
+  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;

package/dist/types/runtime-context.d.ts

@@ -2,8 +2,9 @@
 import { Store } from '@modern-js-reduck/store';
 import { createLoaderManager } from './core/loader/loaderManager';
 import { runtime } from './core/plugin';
-import { SSRServerContext } from './ssr/serverRender/type';
+import { SSRServerContext } from './ssr/serverRender/types';
 export interface BaseRuntimeContext {
+  initialData?: Record<string, unknown>;
   loaderManager: ReturnType<typeof createLoaderManager>;
   runner: ReturnType<typeof runtime.init>;
   ssrContext?: SSRServerContext;
@@ -13,6 +14,7 @@ export interface RuntimeContext extends BaseRuntimeContext {
   [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'];

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

@@ -1,5 +1,3 @@
 import type { CliPlugin } from '@modern-js/core';
-
 declare const _default: () => CliPlugin;
-
 export default _default;

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

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

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

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

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

@@ -1,12 +1,12 @@
 import { RuntimeContext } from '../core';
 declare const prefetch: (App: React.ComponentType<any>, context: RuntimeContext) => Promise<{
-  initialData: any;
+  initialData: Record<string, unknown> | undefined;
   i18nData: any;
   loadersData?: undefined;
   storeState?: undefined;
 } | {
   loadersData: Record<string, import("../core/loader/loaderManager").LoaderResult>;
-  initialData: any;
+  initialData: Record<string, unknown> | undefined;
   i18nData: any;
   storeState: any;
 }>;

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

@@ -1,2 +1,4 @@
 import React from 'react';
-export declare const NoSSR: (props: React.PropsWithChildren<unknown>) => React.FunctionComponentElement<{}>;
+export declare const NoSSR: (props: React.PropsWithChildren<unknown>) => React.FunctionComponentElement<{
+  children?: React.ReactNode;
+}>;

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

@@ -1,3 +1,2 @@
-import { RuntimeContext } from '../../core';
-import { ModernSSRReactComponent, SSRPluginConfig } from './type';
-export declare const render: (ctx: RuntimeContext, config: SSRPluginConfig, App: ModernSSRReactComponent) => Promise<string>;
+import { ServerRenderOptions } from './types';
+export default function serverRender(options: ServerRenderOptions): Promise<any>;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { ChunkExtractor } from '@loadable/server';
+import { RuntimeContext } from '../types';
+export declare function getLoadableChunks({
+  context,
+  jsx
+}: {
+  context: RuntimeContext;
+  jsx: React.ReactElement;
+}): {
+  jsx: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+  chunkExtractor?: undefined;
+} | {
+  jsx: ReactElement<any, any>;
+  chunkExtractor: ChunkExtractor;
+};

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

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+/// <reference types="react" />
+import { Writable } from 'stream';
+import { RenderToPipeableStreamOptions } from 'react-dom/server';
+import { RuntimeContext } from '../types';
+export declare 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;

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

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { ServerStyleSheet } from 'styled-components';
+export declare function getStyledComponentCss({
+  jsx
+}: {
+  jsx: React.ReactElement;
+}): {
+  styleSheet: ServerStyleSheet;
+  jsx: import("react").ReactElement<{
+    sheet: ServerStyleSheet;
+  }, string | import("react").JSXElementConstructor<any>>;
+};

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

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

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

@@ -0,0 +1,4 @@
+export declare type InjectTemplate = {
+  shellBefore?: string;
+  shellAfter?: string;
+};

package/dist/types/ssr/serverRender/{entry.d.ts → renderToString/entry.d.ts}

@@ -1,5 +1,5 @@
-import { RuntimeContext } from '../../core';
-import { ModernSSRReactComponent, SSRServerContext, RenderResult, SSRPluginConfig } from './type';
+import { RuntimeContext, ModernSSRReactComponent, SSRPluginConfig } from '../types';
+import { SSRServerContext, RenderResult } from './type';
 declare type EntryOptions = {
   ctx: SSRServerContext;
   App: ModernSSRReactComponent;

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

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

package/dist/types/ssr/serverRender/{type.d.ts → renderToString/type.d.ts}

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import type { BaseSSRServerContext } from '@modern-js/types';
-import type { RuntimeContext } from '../../core';
+import type { SSRPluginConfig } from '../types';
 export declare enum RenderLevel {
   CLIENT_RENDER = 0,
   SERVER_PREFETCH = 1,
@@ -12,10 +12,6 @@ export declare type SSRServerContext = BaseSSRServerContext & {
     cookie: string;
   };
 };
-export declare type ModernSSRReactComponent = React.ComponentType<any> & {
-  init: (context: RuntimeContext) => Promise<void>;
-  prefetch: (context: RuntimeContext) => Promise<Record<string, any>>;
-};
 export interface RenderEntry {
   entryName: string;
   host: string;
@@ -31,7 +27,4 @@ export declare type RenderResult = {
     js: string;
     css: string;
   };
-};
-export declare type SSRPluginConfig = {
-  crossorigin?: boolean | 'anonymous' | 'use-credentials';
 };

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

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import type { ServerConfig } from '@modern-js/core';
+import type { RuntimeContext } from '../../core';
+import { RenderLevel } from './renderToString/type';
+export type { SSRServerContext } from './renderToString/type';
+export declare type ModernSSRReactComponent = React.ComponentType<any>;
+export { RuntimeContext, RenderLevel };
+export declare type SSRPluginConfig = {
+  crossorigin?: boolean | 'anonymous' | 'use-credentials';
+} & Exclude<ServerConfig['ssr'], boolean>;
+export declare type ServerRenderOptions = {
+  App: ModernSSRReactComponent;
+  config: SSRPluginConfig;
+  context: RuntimeContext;
+};

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

@@ -0,0 +1,3 @@
+import { ChunkExtractor } from '@loadable/server';
+export declare function getLoadableScripts(extractor: ChunkExtractor): string;
+export declare const time: () => () => number;

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

@@ -1,9 +1,11 @@
 import { BaseSSRServerContext } from '@modern-js/types';
-import { SSRServerContext } from './serverRender/type';
+import { SSRServerContext } from './serverRender/types';
+export declare const isReact18: () => boolean;
 export declare const formatServer: (request: BaseSSRServerContext['request']) => SSRServerContext['request'];
 export declare const formatClient: (request: BaseSSRServerContext['request']) => SSRServerContext['request'];
 export declare const mockResponse: () => {
   setHeader(): void;
   status(): void;
+  readonly locals: {};
 };
-export declare const isCrossOrigin: (url: string, base: string) => boolean;
+export declare const isCrossOrigin: (url: string | undefined, base: string) => boolean;

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

@@ -1,5 +1,3 @@
 import type { CliPlugin } from '@modern-js/core';
-
 declare const _default: () => CliPlugin;
-
 export default _default;

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

@@ -1,6 +1,6 @@
 import type { Plugin } from '../../core';
 export declare type StatePluginType = 'immer' | 'effects' | 'autoActions' | 'devtools';
-export declare type StateConfig = Record<Partial<StatePluginType>, boolean>;
+export declare type StateConfig = Partial<Record<StatePluginType, boolean>>;
 declare const state: (config: StateConfig) => Plugin;
 export default state;
 export * from '../plugins';

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

@@ -11,7 +11,6 @@ export declare type PluginOptions = Parameters<typeof createStore>[0] & {
    * Default: false
    * When it's true, will remove immer plugin
    */
-
   disableImmer?: boolean;
   devtools?: any;
 };