@modern-js/runtime 1.21.2 → 2.0.0-beta.0

package/dist/js/treeshaking/ssr/serverRender/{loadable.js → renderToString/loadable.js}

@@ -1,27 +1,15 @@
 import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import { ChunkExtractor } from '@loadable/server';
-import { isCrossOrigin } from "../utils";
+import { isCrossOrigin } from "../../utils";
+import { getLoadableScripts } from "../utils";
 
 var extname = function extname(uri) {
-  return uri.match(/\.[^.]+$/) || '';
-};
-
-function getLoadableScripts(extractor) {
-  var check = function check(scripts) {
-    return (scripts || '').includes('__LOADABLE_REQUIRED_CHUNKS___ext');
-  };
-
-  var scripts = extractor.getScriptTags();
-
-  if (!check(scripts)) {
+  if (typeof uri !== 'string' || !uri.includes('.')) {
     return '';
   }
 
-  return scripts.split('</script>') // 前两个 script为 loadable 必须的 script
-  .slice(0, 2).map(function (i) {
-    return "".concat(i, "</script>");
-  }).join('');
-}
+  return ".".concat(uri === null || uri === void 0 ? void 0 : uri.split('.').pop()) || '';
+};
 
 export var toHtml = function toHtml(jsx, renderer, next) {
   var stats = renderer.stats,

package/dist/js/treeshaking/ssr/serverRender/{type.js → renderToString/type.js}

@@ -1,4 +1,3 @@
-// import { IncomingHttpHeaders } from 'http';
 export var RenderLevel;
 
 (function (RenderLevel) {

package/dist/js/treeshaking/ssr/serverRender/types.js

@@ -0,0 +1,2 @@
+import { RenderLevel } from "./renderToString/type";
+export { RenderLevel };

package/dist/js/treeshaking/ssr/serverRender/{measure.js → utils.js}

@@ -1,4 +1,20 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+export function getLoadableScripts(extractor) {
+  var check = function check(scripts) {
+    return (scripts || '').includes('__LOADABLE_REQUIRED_CHUNKS___ext');
+  };
+
+  var scripts = extractor.getScriptTags();
+
+  if (!check(scripts)) {
+    return '';
+  }
+
+  return scripts.split('</script>') // 前两个 script为 loadable 必须的 script
+  .slice(0, 2).map(function (i) {
+    return "".concat(i, "</script>");
+  }).join('');
+}
 
 var getLatency = function getLatency(hrtime) {
   var _process$hrtime = process.hrtime(hrtime),

package/dist/js/treeshaking/ssr/utils.js

@@ -1,5 +1,8 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+export var isReact18 = function isReact18() {
+  return process.env.IS_REACT18 === 'true';
+};
 export var formatServer = function formatServer(request) {
   var _ref = request.headers || {},
       _ref$cookie = _ref.cookie,
@@ -49,14 +52,23 @@ export var formatClient = function formatClient(request) {
 export var mockResponse = function mockResponse() {
   return {
     setHeader: function setHeader() {
-      console.info('setHeader can only be used in the server side');
+      console.warn('response.setHeader() can only be used in the server side');
     },
     status: function status() {
-      console.info('status can only be used in the server side');
+      console.warn('response.status() can only be used in the server side');
+    },
+
+    get locals() {
+      console.warn('response.locals can only be used in the server side');
+      return {};
     }
+
   };
 };
-export var isCrossOrigin = function isCrossOrigin(url, base) {
+export var isCrossOrigin = function isCrossOrigin() {
+  var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var base = arguments.length > 1 ? arguments[1] : undefined;
+
   if (url.startsWith('/') || url.startsWith('./')) {
     return false;
   } else if (!url.includes(base)) {

package/dist/types/common.d.ts

@@ -1,8 +1,6 @@
 import type { StateConfig } from './state';
-import type { RouterConfig } from './router';
 export declare const isBrowser: () => boolean;
 export interface AppConfig {
-  router?: RouterConfig | boolean;
   state?: StateConfig | boolean;
   [key: string]: any;
 }

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

@@ -3,6 +3,6 @@ export type { Plugin } from './plugin';
 export { defineConfig, getConfig } from './app-config';
 export * from './compatible';
 export type { TRuntimeContext, RuntimeContext } from '../runtime-context';
-export { RuntimeReactContext } from '../runtime-context';
+export { RuntimeReactContext, ServerRouterContext } from '../runtime-context';
 export * from './loader';
 export * from '@modern-js/plugin';

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

@@ -185,7 +185,7 @@ export declare const createPlugin: (setup?: Setup<{
     context: RuntimeContext;
     pickedContext: TRuntimeContext;
   }, TRuntimeContext>;
-}, Record<string, never>>> | undefined) => import("@modern-js/plugin").Plugin<{
+}, Record<string, never>>, Record<string, unknown>> | undefined) => import("@modern-js/plugin").Plugin<{
   hoc: import("@modern-js/plugin").Pipeline<{
     App: React.ComponentType<any>;
   }, React.ComponentType<any>>;

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

@@ -1 +1,21 @@
-export declare const hook: (attacher: any) => any;
+import { AfterMatchContext, AfterRenderContext, MiddlewareContext, NextFunction } from '@modern-js/types';
+export declare const hook: (attacher: ({
+  addMiddleware,
+  afterMatch,
+  afterRender
+}: {
+  addMiddleware: (mid: RequestHandler) => void;
+  afterRender: (hook: AfterRenderHook) => void;
+  afterMatch: (hook: AfterMatchHook) => void;
+}) => void) => ({
+  addMiddleware,
+  afterMatch,
+  afterRender
+}: {
+  addMiddleware: (mid: RequestHandler) => void;
+  afterRender: (hook: AfterRenderHook) => void;
+  afterMatch: (hook: AfterMatchHook) => void;
+}) => void;
+export declare type AfterRenderHook = (context: AfterRenderContext, next: NextFunction) => void;
+export declare type AfterMatchHook = (context: AfterMatchContext, next: NextFunction) => void;
+export declare type RequestHandler = (context: MiddlewareContext, next: NextFunction) => Promise<void> | void;

package/dist/types/index.d.ts

@@ -2,6 +2,7 @@ import type { StateConfig } from './state';
 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 './runtime-context';
 export { createApp, createPlugin, useLoader, bootstrap, RuntimeReactContext, registerPrefetch, defineConfig, registerInit, useRuntimeContext } from './core';
 export { StateConfig, RouterConfig };

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

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

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/types.d.ts

@@ -0,0 +1,38 @@
+/// <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,7 +2,7 @@
 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 {
   loaderManager: ReturnType<typeof createLoaderManager>;
   runner: ReturnType<typeof runtime.init>;
@@ -13,6 +13,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/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/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,6 @@
+import { RuntimeContext } from 'src/runtime-context';
+declare type BuildShellAfterTemplateOptions = {
+  context: RuntimeContext;
+};
+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 @@
+export declare function buildShellBeforeTemplate(beforeAppTemplate: string): 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 { InjectTemplate } from './type';
+export declare type Pipe<T extends Writable> = (output: T) => Promise<T>;
+declare function renderToPipe(rootElement: React.ReactElement, getTemplates: () => InjectTemplate, 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 { RuntimeContext } from '../types';
+import { InjectTemplate } from './type';
+export declare function createTemplates(context: RuntimeContext): () => 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,18 @@
+/// <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> & {
+  init: (context: RuntimeContext) => Promise<void>;
+  prefetch: (context: RuntimeContext) => Promise<Record<string, 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/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';