@umijs/server 4.0.0-beta.9 → 4.0.0-canary-20240513.3

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-present ChenCheng (sorrycc@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/index.d.ts

@@ -1 +1,2 @@
+export { createServerRoutes } from './routes';
 export * from './server';

package/dist/index.js

@@ -1,13 +1,32 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./server"), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createServerRoutes: () => import_routes.createServerRoutes
+});
+module.exports = __toCommonJS(src_exports);
+var import_routes = require("./routes");
+__reExport(src_exports, require("./server"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServerRoutes,
+  ...require("./server")
+});

package/dist/routes.d.ts

@@ -1,12 +1,15 @@
-import { IRoute, IRoutesById } from './types';
+import { IRoute, IRouteCustom, IRoutesById } from './types';
 export declare function createServerRoutes(opts: {
     routesById: IRoutesById;
     parentId?: string;
-}): {
+    createRoute?: (opts: {
+        route: IRoute;
+    }) => IRouteCustom;
+}): (IRouteCustom | {
     id: string;
     path: string | undefined;
     index: boolean | undefined;
-}[];
+})[];
 export declare function createServerRoute(opts: {
     route: IRoute;
 }): {

package/dist/routes.js

@@ -1,32 +1,55 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createServerRoute = exports.createServerRoutes = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/routes.ts
+var routes_exports = {};
+__export(routes_exports, {
+  createServerRoute: () => createServerRoute,
+  createServerRoutes: () => createServerRoutes
+});
+module.exports = __toCommonJS(routes_exports);
 function createServerRoutes(opts) {
-    const { routesById, parentId } = opts;
-    return Object.keys(routesById)
-        .filter((id) => routesById[id].parentId === parentId)
-        .map((id) => {
-        const route = createServerRoute({
-            route: routesById[id],
-        });
-        const children = createServerRoutes({
-            routesById,
-            parentId: route.id,
-        });
-        if (children.length > 0) {
-            // @ts-ignore
-            route.children = children;
-        }
-        return route;
+  const { routesById, parentId, createRoute } = opts;
+  const createRouteFn = createRoute || createServerRoute;
+  return Object.keys(routesById).filter((id) => routesById[id].parentId === parentId).map((id) => {
+    const route = createRouteFn({
+      route: routesById[id]
     });
+    const children = createServerRoutes({
+      routesById,
+      parentId: route.id
+    });
+    if (children.length > 0) {
+      route.children = children;
+    }
+    return route;
+  });
 }
-exports.createServerRoutes = createServerRoutes;
 function createServerRoute(opts) {
-    const { route } = opts;
-    return {
-        id: route.id,
-        path: route.path,
-        index: route.index,
-    };
+  const { route } = opts;
+  return {
+    id: route.id,
+    path: route.path,
+    index: route.index
+  };
 }
-exports.createServerRoute = createServerRoute;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServerRoute,
+  createServerRoutes
+});

package/dist/scripts.js

@@ -1,33 +1,61 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeScript = exports.normalizeScripts = void 0;
-const assert_1 = __importDefault(require("assert"));
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts.ts
+var scripts_exports = {};
+__export(scripts_exports, {
+  normalizeScript: () => normalizeScript,
+  normalizeScripts: () => normalizeScripts
+});
+module.exports = __toCommonJS(scripts_exports);
+var import_assert = __toESM(require("assert"));
 function normalizeScripts(scripts) {
-    return scripts.map(normalizeScript);
+  return scripts.map(normalizeScript);
 }
-exports.normalizeScripts = normalizeScripts;
-const RE_URL = /^(http:|https:)?\/\//;
+var RE_URL = /^(http:|https:)?\/\//;
 function normalizeScript(script) {
-    if (typeof script === 'string') {
-        const isUrl = RE_URL.test(script) ||
-            script.startsWith('/') ||
-            script.startsWith('./') ||
-            script.startsWith('../');
-        return isUrl
-            ? {
-                src: script,
-            }
-            : { content: script };
-    }
-    else if (typeof script === 'object') {
-        (0, assert_1.default)(typeof script.src === 'string' || typeof script.content === 'string', `Script must have either a "src" or a "content" property.`);
-        return script;
-    }
-    else {
-        throw new Error(`Invalid script type: ${typeof script}`);
-    }
+  if (typeof script === "string") {
+    const isUrl = RE_URL.test(script) || script.startsWith("/") && !script.startsWith("/*") || script.startsWith("./") || script.startsWith("../");
+    return isUrl ? {
+      src: script
+    } : { content: script };
+  } else if (typeof script === "object") {
+    (0, import_assert.default)(
+      typeof script.src === "string" || typeof script.content === "string",
+      `Script must have either a "src" or a "content" property.`
+    );
+    return script;
+  } else {
+    throw new Error(`Invalid script type: ${typeof script}`);
+  }
 }
-exports.normalizeScript = normalizeScript;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeScript,
+  normalizeScripts
+});

package/dist/server.d.ts

@@ -1,5 +1,6 @@
-import type { RequestHandler } from 'express';
-interface IOpts {
+import type { RequestHandler } from '@umijs/bundler-utils/compiled/express';
+export interface IOpts {
+    base: string;
     routes: Record<string, {
         path: string;
         file: string;
@@ -9,16 +10,18 @@ interface IOpts {
     links?: Record<string, string>[];
     metas?: Record<string, string>[];
     styles?: (Record<string, string> | string)[];
-    favicon?: string;
+    favicons?: string[];
+    title?: string;
     headScripts?: (Record<string, string> | string)[];
     scripts?: (Record<string, string> | string)[];
+    mountElementId?: string;
     esmScript?: boolean;
     modifyHTML?: (html: string, args: {
         path?: string;
     }) => Promise<string>;
+    historyType?: 'hash' | 'browser';
 }
 export declare function getMarkup(opts: Omit<IOpts, 'routes'> & {
     path?: string;
 }): Promise<string>;
 export declare function createRequestHandler(opts: IOpts): RequestHandler;
-export {};

package/dist/server.js

@@ -1,113 +1,153 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRequestHandler = exports.getMarkup = void 0;
-const react_1 = __importDefault(require("react"));
-const server_1 = __importDefault(require("react-dom/server"));
-const react_router_dom_1 = require("react-router-dom");
-const routes_1 = require("./routes");
-const scripts_1 = require("./scripts");
-const styles_1 = require("./styles");
-function getMarkup(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // TODO: use real component
-        let markup = server_1.default.renderToString(react_1.default.createElement('div', { id: 'root' }));
-        function propsToString(opts) {
-            return Object.keys(opts.props)
-                .filter((key) => !(opts.filters || []).includes(key))
-                .map((key) => `${key}=${JSON.stringify(opts.props[key])}`)
-                .join(' ');
-        }
-        function getScriptContent(script) {
-            const attrs = propsToString({
-                props: script,
-                filters: ['src', 'content'],
-            });
-            return script.src
-                ? `<script${opts.esmScript ? ' type="module"' : ''} ${attrs} src="${script.src}"></script>`
-                : `<script${opts.esmScript ? ' type="module"' : ''} ${attrs}>${script.content}</script>`;
-        }
-        function getStyleContent(style) {
-            const attrs = propsToString({
-                props: style,
-                filters: ['src', 'content'],
-            });
-            return style.src
-                ? `<link rel="stylesheet" ${attrs} src="${style.src}" />`
-                : `<style ${attrs}>${style.content}</style>`;
-        }
-        function getTagContent(opts) {
-            const attrs = propsToString({
-                props: opts.attrs,
-            });
-            return `<${opts.tagName} ${attrs} />`;
-        }
-        const favicon = opts.favicon
-            ? `<link rel="shortcut icon" href="${opts.favicon}">`
-            : '';
-        const metas = (opts.metas || []).map((meta) => getTagContent({ attrs: meta, tagName: 'meta' }));
-        const links = (opts.links || []).map((link) => getTagContent({ attrs: link, tagName: 'link' }));
-        const styles = (0, styles_1.normalizeStyles)(opts.styles || []).map(getStyleContent);
-        const headScripts = (0, scripts_1.normalizeScripts)(opts.headScripts || []).map(getScriptContent);
-        const scripts = (0, scripts_1.normalizeScripts)(opts.scripts || []).map(getScriptContent);
-        markup = [
-            `<!DOCTYPE html>
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createRequestHandler: () => createRequestHandler,
+  getMarkup: () => getMarkup
+});
+module.exports = __toCommonJS(server_exports);
+var import_react = __toESM(require("react"));
+var import_server = __toESM(require("react-dom/server"));
+var import_scripts = require("./scripts");
+var import_styles = require("./styles");
+async function getMarkup(opts) {
+  let markup = import_server.default.renderToString(
+    import_react.default.createElement("div", { id: opts.mountElementId || "root" })
+  );
+  function propsToString(opts2) {
+    return Object.keys(opts2.props).filter((key) => {
+      const isValidBoolean = opts2.props[key] !== false;
+      return !(opts2.filters || []).includes(key) && isValidBoolean;
+    }).map((key) => {
+      const value = opts2.props[key];
+      if (value === true) {
+        return `${key}`;
+      }
+      return `${key}=${JSON.stringify(value)}`;
+    }).join(" ");
+  }
+  function getScriptContent(script) {
+    const attrs = propsToString({
+      props: script,
+      filters: ["src", "content"]
+    });
+    const isEsmScript = opts.esmScript && !("type" in script);
+    return script.src ? `<script${isEsmScript ? ' type="module"' : ""} ${attrs} src="${script.src}"></script>` : `<script${isEsmScript ? ' type="module"' : ""} ${attrs}>${script.content}</script>`;
+  }
+  function getStyleContent(style) {
+    const attrs = propsToString({
+      props: style,
+      filters: ["src", "content"]
+    });
+    return style.src ? `<link rel="stylesheet" ${attrs} href="${style.src}" />` : `<style ${attrs}>${style.content}</style>`;
+  }
+  function getTagContent(opts2) {
+    const attrs = propsToString({
+      props: opts2.attrs
+    });
+    return `<${opts2.tagName} ${attrs} />`;
+  }
+  function withDefaultMetas(metas2 = []) {
+    const hasAttr = (key, value) => metas2.some((m) => {
+      var _a;
+      return value ? ((_a = m[key]) == null ? void 0 : _a.toLowerCase()) === value.toLowerCase() : m[key];
+    });
+    return [
+      !hasAttr("charset") && { charset: "utf-8" },
+      !hasAttr("name", "viewport") && {
+        name: "viewport",
+        content: "width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"
+      },
+      !hasAttr("http-equiv", "X-UA-Compatible") && {
+        "http-equiv": "X-UA-Compatible",
+        content: "ie=edge"
+      },
+      ...metas2
+    ].filter(Boolean);
+  }
+  const favicons = [];
+  if (Array.isArray(opts.favicons)) {
+    opts.favicons.forEach((e) => {
+      favicons.push(`<link rel="shortcut icon" href="${e}">`);
+    });
+  }
+  const title = opts.title ? `<title>${opts.title}</title>` : "";
+  const metas = withDefaultMetas(opts.metas).map(
+    (meta) => getTagContent({ attrs: meta, tagName: "meta" })
+  );
+  const links = (opts.links || []).map(
+    (link) => getTagContent({ attrs: link, tagName: "link" })
+  );
+  const styles = (0, import_styles.normalizeStyles)(opts.styles || []).map(getStyleContent);
+  const headScripts = (0, import_scripts.normalizeScripts)(opts.headScripts || []).map(
+    getScriptContent
+  );
+  const scripts = (0, import_scripts.normalizeScripts)(opts.scripts || []).map(getScriptContent);
+  markup = [
+    `<!DOCTYPE html>
 <html>
-<head>
-<meta charset="UTF-8" />
-<meta
-  name="viewport"
-  content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"
-/>
-<meta http-equiv="X-UA-Compatible" content="ie=edge" />`,
-            metas.join('\n'),
-            favicon,
-            links.join('\n'),
-            styles.join('\n'),
-            headScripts.join('\n'),
-            `</head>
+<head>`,
+    metas.join("\n"),
+    favicons.join("\n"),
+    title,
+    links.join("\n"),
+    styles.join("\n"),
+    headScripts.join("\n"),
+    `</head>
 <body>`,
-            markup,
-            scripts.join('\n'),
-            `</body>
-</html>`,
-        ]
-            .filter(Boolean)
-            .join('\n');
-        if (opts.modifyHTML) {
-            markup = yield opts.modifyHTML(markup, { path: opts.path });
-        }
-        return markup;
-    });
+    markup,
+    scripts.join("\n"),
+    `</body>
+</html>`
+  ].filter(Boolean).join("\n");
+  if (opts.modifyHTML) {
+    markup = await opts.modifyHTML(markup, { path: opts.path });
+  }
+  return markup;
 }
-exports.getMarkup = getMarkup;
 function createRequestHandler(opts) {
-    return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
-        // 匹配路由，不匹配走 next()
-        // TODO: cache
-        const routes = (0, routes_1.createServerRoutes)({
-            routesById: opts.routes,
-        });
-        const matches = (0, react_router_dom_1.matchRoutes)(routes, req.path);
-        if (matches) {
-            res.set('Content-Type', 'text/html');
-            const markup = yield getMarkup(Object.assign(Object.assign({}, opts), { path: req.path }));
-            res.end(markup);
-        }
-        else {
-            next();
-        }
-    });
+  return async (req, res, next) => {
+    var _a;
+    if (opts.historyType === "browser" && opts.base !== "/" && req.path === "/" && process.env.DEV_SERVER_REDIRECT !== "none") {
+      res.redirect(opts.base);
+    } else if (((_a = req.headers.accept) == null ? void 0 : _a.includes("text/html")) || req.headers.accept === "*/*" || req.path === opts.base) {
+      res.set("Content-Type", "text/html");
+      const markup = await getMarkup({ ...opts, path: req.path });
+      res.end(markup);
+    } else {
+      next();
+    }
+  };
 }
-exports.createRequestHandler = createRequestHandler;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRequestHandler,
+  getMarkup
+});

package/dist/ssr.d.ts

@@ -0,0 +1,45 @@
+/// <reference lib="webworker" />
+import type { RequestHandler } from '@umijs/bundler-utils/compiled/express';
+import React from 'react';
+import type { IhtmlPageOpts, UmiRequest } from './types';
+interface RouteLoaders {
+    [key: string]: () => Promise<any>;
+}
+export declare type ServerInsertedHTMLHook = (callbacks: () => React.ReactNode) => void;
+interface CreateRequestServerlessOptions {
+    /**
+     * folder path for `build-manifest.json`
+     */
+    sourceDir?: string;
+}
+interface CreateRequestHandlerOptions extends CreateRequestServerlessOptions {
+    routesWithServerLoader: RouteLoaders;
+    pluginManager: any;
+    manifest: ((sourceDir?: string) => {
+        assets: Record<string, string>;
+    }) | {
+        assets: Record<string, string>;
+    };
+    getRoutes: (PluginManager: any) => any;
+    getClientRootComponent: (PluginManager: any) => any;
+    createHistory: (opts: any) => any;
+    helmetContext?: any;
+    ServerInsertedHTMLContext: React.Context<ServerInsertedHTMLHook | null>;
+    htmlPageOpts: IhtmlPageOpts;
+    renderFromRoot: boolean;
+    __SPECIAL_HTML_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: boolean;
+    mountElementId: string;
+}
+export declare function createMarkupGenerator(opts: CreateRequestHandlerOptions): (url: string) => Promise<unknown>;
+declare type IExpressRequestHandlerArgs = Parameters<RequestHandler>;
+declare type IWorkerRequestHandlerArgs = [
+    ev: FetchEvent,
+    opts?: {
+        modifyResponse?: (res: Response) => Promise<Response> | Response;
+    }
+];
+export default function createRequestHandler(opts: CreateRequestHandlerOptions): (...args: IExpressRequestHandlerArgs | IWorkerRequestHandlerArgs) => Promise<void>;
+export declare function createUmiHandler(opts: CreateRequestHandlerOptions): (req: UmiRequest, params?: CreateRequestHandlerOptions) => Promise<NodeJS.ReadableStream>;
+export declare function createUmiServerLoader(opts: CreateRequestHandlerOptions): (req: UmiRequest) => Promise<any>;
+export declare function createAppRootElement(opts: CreateRequestHandlerOptions): (...args: IExpressRequestHandlerArgs | IWorkerRequestHandlerArgs) => Promise<() => React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined>;
+export {};