npm - @modern-js/prod-server - Versions diffs - 1.21.6 → 2.0.0-alpha.0 - Mend

@modern-js/prod-server 1.21.6 → 2.0.0-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (132) hide show

package/CHANGELOG.md +274 -13
package/dist/js/modern/constants.js +32 -27
package/dist/js/modern/index.js +11 -7
package/dist/js/modern/libs/context/context.js +54 -132
package/dist/js/modern/libs/context/index.js +5 -2
package/dist/js/modern/libs/hook-api/index.js +134 -0
package/dist/js/modern/libs/hook-api/route.js +13 -37
package/dist/js/modern/libs/hook-api/template.js +41 -32
package/dist/js/modern/libs/loadConfig.js +46 -32
package/dist/js/modern/libs/metrics.js +6 -7
package/dist/js/modern/libs/proxy.js +70 -44
package/dist/js/modern/libs/render/cache/__tests__/cache.fun.test.js +112 -68
package/dist/js/modern/libs/render/cache/__tests__/cache.test.js +246 -225
package/dist/js/modern/libs/render/cache/__tests__/cacheable.js +43 -49
package/dist/js/modern/libs/render/cache/__tests__/error-configuration.js +36 -34
package/dist/js/modern/libs/render/cache/__tests__/matched-cache.js +83 -113
package/dist/js/modern/libs/render/cache/index.js +93 -50
package/dist/js/modern/libs/render/cache/page-caches/index.js +31 -8
package/dist/js/modern/libs/render/cache/page-caches/lru.js +6 -16
package/dist/js/modern/libs/render/cache/spr.js +133 -167
package/dist/js/modern/libs/render/cache/type.js +0 -1
package/dist/js/modern/libs/render/cache/util.js +71 -45
package/dist/js/modern/libs/render/index.js +76 -61
package/dist/js/modern/libs/render/measure.js +42 -34
package/dist/js/modern/libs/render/reader.js +68 -76
package/dist/js/modern/libs/render/ssr.js +63 -33
package/dist/js/modern/libs/render/static.js +51 -37
package/dist/js/modern/libs/render/type.js +9 -7
package/dist/js/modern/libs/route/index.js +12 -30
package/dist/js/modern/libs/route/matcher.js +28 -50
package/dist/js/modern/libs/route/route.js +9 -31
package/dist/js/modern/libs/serve-file.js +40 -20
package/dist/js/modern/server/index.js +152 -168
package/dist/js/modern/server/modern-server-split.js +44 -60
package/dist/js/modern/server/modern-server.js +416 -526
package/dist/js/modern/type.js +0 -1
package/dist/js/modern/utils.js +62 -58
package/dist/js/modern/worker-server.js +54 -0
package/dist/js/node/constants.js +53 -32
package/dist/js/node/index.js +37 -67
package/dist/js/node/libs/context/context.js +84 -150
package/dist/js/node/libs/context/index.js +28 -16
package/dist/js/node/libs/hook-api/index.js +164 -0
package/dist/js/node/libs/hook-api/route.js +35 -45
package/dist/js/node/libs/hook-api/template.js +64 -40
package/dist/js/node/libs/loadConfig.js +74 -55
package/dist/js/node/libs/metrics.js +28 -12
package/dist/js/node/libs/proxy.js +90 -55
package/dist/js/node/libs/render/cache/__tests__/cache.fun.test.js +99 -61
package/dist/js/node/libs/render/cache/__tests__/cache.test.js +147 -140
package/dist/js/node/libs/render/cache/__tests__/cacheable.js +65 -55
package/dist/js/node/libs/render/cache/__tests__/error-configuration.js +58 -40
package/dist/js/node/libs/render/cache/__tests__/matched-cache.js +105 -119
package/dist/js/node/libs/render/cache/index.js +115 -65
package/dist/js/node/libs/render/cache/page-caches/index.js +54 -16
package/dist/js/node/libs/render/cache/page-caches/lru.js +33 -26
package/dist/js/node/libs/render/cache/spr.js +161 -188
package/dist/js/node/libs/render/cache/type.js +15 -5
package/dist/js/node/libs/render/cache/util.js +99 -63
package/dist/js/node/libs/render/index.js +106 -87
package/dist/js/node/libs/render/measure.js +61 -44
package/dist/js/node/libs/render/reader.js +98 -100
package/dist/js/node/libs/render/ssr.js +92 -58
package/dist/js/node/libs/render/static.js +80 -53
package/dist/js/node/libs/render/type.js +31 -13
package/dist/js/node/libs/route/index.js +35 -44
package/dist/js/node/libs/route/matcher.js +48 -65
package/dist/js/node/libs/route/route.js +29 -37
package/dist/js/node/libs/serve-file.js +74 -37
package/dist/js/node/server/index.js +170 -203
package/dist/js/node/server/modern-server-split.js +70 -73
package/dist/js/node/server/modern-server.js +432 -577
package/dist/js/node/type.js +15 -3
package/dist/js/node/utils.js +87 -93
package/dist/js/node/worker-server.js +77 -0
package/dist/js/treeshaking/constants.js +29 -0
package/dist/js/treeshaking/index.js +13 -0
package/dist/js/treeshaking/libs/context/context.js +274 -0
package/dist/js/treeshaking/libs/context/index.js +5 -0
package/dist/js/treeshaking/libs/hook-api/index.js +281 -0
package/dist/js/treeshaking/libs/hook-api/route.js +68 -0
package/dist/js/treeshaking/libs/hook-api/template.js +127 -0
package/dist/js/treeshaking/libs/loadConfig.js +82 -0
package/dist/js/treeshaking/libs/metrics.js +6 -0
package/dist/js/treeshaking/libs/proxy.js +244 -0
package/dist/js/treeshaking/libs/render/cache/__tests__/cache.fun.test.js +291 -0
package/dist/js/treeshaking/libs/render/cache/__tests__/cache.test.js +781 -0
package/dist/js/treeshaking/libs/render/cache/__tests__/cacheable.js +67 -0
package/dist/js/treeshaking/libs/render/cache/__tests__/error-configuration.js +45 -0
package/dist/js/treeshaking/libs/render/cache/__tests__/matched-cache.js +147 -0
package/dist/js/treeshaking/libs/render/cache/index.js +346 -0
package/dist/js/treeshaking/libs/render/cache/page-caches/index.js +154 -0
package/dist/js/treeshaking/libs/render/cache/page-caches/lru.js +84 -0
package/dist/js/treeshaking/libs/render/cache/spr.js +492 -0
package/dist/js/treeshaking/libs/render/cache/type.js +1 -0
package/dist/js/treeshaking/libs/render/cache/util.js +280 -0
package/dist/js/treeshaking/libs/render/index.js +233 -0
package/dist/js/treeshaking/libs/render/measure.js +146 -0
package/dist/js/treeshaking/libs/render/reader.js +339 -0
package/dist/js/treeshaking/libs/render/ssr.js +223 -0
package/dist/js/treeshaking/libs/render/static.js +216 -0
package/dist/js/treeshaking/libs/render/type.js +7 -0
package/dist/js/treeshaking/libs/route/index.js +130 -0
package/dist/js/treeshaking/libs/route/matcher.js +138 -0
package/dist/js/treeshaking/libs/route/route.js +40 -0
package/dist/js/treeshaking/libs/serve-file.js +184 -0
package/dist/js/treeshaking/server/index.js +505 -0
package/dist/js/treeshaking/server/modern-server-split.js +360 -0
package/dist/js/treeshaking/server/modern-server.js +1083 -0
package/dist/js/treeshaking/type.js +1 -0
package/dist/js/treeshaking/utils.js +147 -0
package/dist/js/treeshaking/worker-server.js +177 -0
package/dist/types/libs/context/context.d.ts +1 -1
package/dist/types/libs/hook-api/index.d.ts +5 -0
package/dist/types/libs/hook-api/route.d.ts +9 -14
package/dist/types/libs/hook-api/template.d.ts +19 -9
package/dist/types/libs/render/cache/index.d.ts +4 -2
package/dist/types/libs/render/type.d.ts +3 -1
package/dist/types/libs/route/route.d.ts +0 -1
package/dist/types/libs/serve-file.d.ts +2 -1
package/dist/types/server/index.d.ts +2 -0
package/dist/types/server/modern-server.d.ts +11 -11
package/dist/types/type.d.ts +8 -10
package/dist/types/utils.d.ts +3 -4
package/dist/types/worker-server.d.ts +15 -0
package/package.json +31 -45
package/dist/js/modern/libs/render/modern/browser-list.js +0 -7
package/dist/js/modern/libs/render/modern/index.js +0 -48
package/dist/js/node/libs/render/modern/browser-list.js +0 -14
package/dist/js/node/libs/render/modern/index.js +0 -64
package/dist/types/libs/render/modern/browser-list.d.ts +0 -1
package/dist/types/libs/render/modern/index.d.ts +0 -3

package/dist/js/treeshaking/type.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ "use strict";

package/dist/js/treeshaking/utils.js ADDED Viewed

@@ -0,0 +1,147 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import { createDebugger, isProd } from "@modern-js/utils";
+var debug = createDebugger("prod-server");
+var mergeExtension = function(users) {
+    var output = [];
+    return {
+        middleware: output.concat(users)
+    };
+};
+var noop = function() {};
+var createErrorDocument = function(status, text) {
+    var title = "".concat(status, ": ").concat(text);
+    return '<!DOCTYPE html>\n  <html lang="en">\n  <head>\n    <meta charset="utf-8">\n    <meta name="viewport" content="width=device-width">\n    <title>'.concat(title, '</title>\n    <style>\n      html,body {\n        margin: 0;\n      }\n\n      .page-container {\n        color: #000;\n        background: #fff;\n        height: 100vh;\n        text-align: center;\n        display: flex;\n        flex-direction: column;\n        align-items: center;\n        justify-content: center;\n      }\n    </style>\n  </head>\n  <body>\n    <div class="page-container">\n    <h1>').concat(status, "</h1>\n    <div>").concat(text, "</div>\n  </body>\n  </html>\n  ");
+};
+var createMiddlewareCollecter = function() {
+    var webMiddlewares = [];
+    var apiMiddlewares = [];
+    var addWebMiddleware = function(input) {
+        webMiddlewares.push(input);
+    };
+    var addAPIMiddleware = function(input) {
+        apiMiddlewares.push(input);
+    };
+    var getMiddlewares = function() {
+        return {
+            web: webMiddlewares,
+            api: apiMiddlewares
+        };
+    };
+    return {
+        getMiddlewares: getMiddlewares,
+        addWebMiddleware: addWebMiddleware,
+        addAPIMiddleware: addAPIMiddleware
+    };
+};
+var useLocalPrefix = function(url) {
+    return isProd() && !url.includes(".");
+};
+var getStaticReg = function() {
+    var output = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, html = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var tmp = output.distPath, ref = tmp === void 0 ? {} : tmp, cssPath = ref.css, jsPath = ref.js, mediaPath = ref.media, _assetPrefix = output.assetPrefix, assetPrefix = _assetPrefix === void 0 ? "/" : _assetPrefix;
+    var favicon = html.favicon, faviconByEntries = html.faviconByEntries;
+    var prefix = useLocalPrefix(assetPrefix) ? assetPrefix : "";
+    var favicons = prepareFavicons(favicon, faviconByEntries);
+    var staticFiles = [
+        cssPath,
+        jsPath,
+        mediaPath
+    ].filter(function(v) {
+        return Boolean(v);
+    });
+    var staticReg = [
+        "static/",
+        "upload/"
+    ].concat(_toConsumableArray(staticFiles));
+    var iconReg = [
+        "favicon.ico",
+        "icon.png"
+    ].concat(_toConsumableArray(favicons));
+    var regPrefix = prefix.endsWith("/") ? prefix : "".concat(prefix, "/");
+    var staticPathRegExp = new RegExp("^".concat(regPrefix, "(").concat(_toConsumableArray(staticReg).concat(_toConsumableArray(iconReg)).join("|"), ")"));
+    return staticPathRegExp;
+};
+var prepareFavicons = function(favicon, faviconByEntries) {
+    var faviconNames = [];
+    if (favicon) {
+        faviconNames.push(favicon.substring(favicon.lastIndexOf("/") + 1));
+    }
+    if (faviconByEntries) {
+        Object.keys(faviconByEntries).forEach(function(f) {
+            var curFavicon = faviconByEntries[f];
+            if (curFavicon) {
+                faviconNames.push(curFavicon.substring(curFavicon.lastIndexOf("/") + 1));
+            }
+        });
+    }
+    return faviconNames;
+};
+var headersWithoutCookie = function(headers) {
+    if (typeof headers.cookie !== "undefined") {
+        var safeHeaders = _objectSpread({}, headers);
+        delete safeHeaders.cookie;
+        return safeHeaders;
+    }
+    return headers;
+};
+var isRedirect = function(code) {
+    return [
+        301,
+        302,
+        307,
+        308
+    ].includes(code);
+};
+export { createErrorDocument, createMiddlewareCollecter, debug, getStaticReg, headersWithoutCookie, isRedirect, mergeExtension, noop, prepareFavicons, useLocalPrefix };

package/dist/js/treeshaking/worker-server.js ADDED Viewed

@@ -0,0 +1,177 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return(g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g);
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+var _request, _request1, _request2;
+import { RouteMatchManager } from "./libs/route";
+var createHandler = function(manifest) {
+    var routeMgr = new RouteMatchManager();
+    var pages = manifest.pages, routes = manifest.routes;
+    routeMgr.reset(routes);
+    return function() {
+        var _ref = _asyncToGenerator(function(ctx) {
+            var pageMatch, page, _query, _pathname, _params, params;
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        pageMatch = routeMgr.match(ctx.url);
+                        if (!pageMatch) {
+                            ctx.body = "404: Page not found";
+                            ctx.status = 404;
+                            return [
+                                2
+                            ];
+                        }
+                        page = pages[pageMatch.spec.urlPath];
+                        (_query = (_request = ctx.request).query) !== null && _query !== void 0 ? _query : _request.query = ctx.query;
+                        (_pathname = (_request1 = ctx.request).pathname) !== null && _pathname !== void 0 ? _pathname : _request1.pathname = ctx.pathname;
+                        (_params = (_request2 = ctx.request).params) !== null && _params !== void 0 ? _params : _request2.params = ctx.params;
+                        params = pageMatch.parseURLParams(ctx.url);
+                        return [
+                            4,
+                            page.serverRender({
+                                template: page.template,
+                                query: ctx.query,
+                                request: ctx.request,
+                                response: ctx.response,
+                                pathname: ctx.pathname,
+                                req: ctx.request,
+                                res: ctx.response,
+                                params: ctx.params || params || {}
+                            })
+                        ];
+                    case 1:
+                        ctx.body = _state.sent();
+                        ctx.status = 200;
+                        return [
+                            2
+                        ];
+                }
+            });
+        });
+        return function(ctx) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+};
+export { createHandler };

package/dist/types/libs/context/context.d.ts CHANGED Viewed

@@ -1,9 +1,9 @@
-/// <reference path="../../type.d.ts" />
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node/http" />
+/// <reference types=".dts-temp/8-abj5cxwfao2-yqb9uay/src/type" />
 import { IncomingMessage, ServerResponse } from 'http';
 import { URL } from 'url';
 import qs from 'querystring';

package/dist/types/libs/hook-api/index.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import type { ModernServerContext, HookContext, AfterMatchContext, AfterRenderContext, MiddlewareContext } from '@modern-js/types';
+export declare const base: (context: ModernServerContext) => HookContext;
+export declare const createAfterMatchContext: (context: ModernServerContext, entryName: string) => AfterMatchContext;
+export declare const createAfterRenderContext: (context: ModernServerContext, content: string) => AfterRenderContext;
+export declare const createMiddlewareContext: (context: ModernServerContext) => MiddlewareContext;

package/dist/types/libs/hook-api/route.d.ts CHANGED Viewed

@@ -1,14 +1,9 @@
-import { RouteMatchManager, RouteMatcher } from '../route';
-declare class RouteAPI {
-  private readonly router;
-  private current;
-  private readonly url;
-  constructor(matched: RouteMatcher, router: RouteMatchManager, url: string);
-  cur(): import("../route").ModernRoute;
-  get(entryName: string): import("../route").ModernRoute | null;
-  use(entryName: string): boolean;
-}
-export declare const createRouteAPI: (matched: RouteMatcher, router: RouteMatchManager, url: string) => RouteAPI;
-export {};
+export declare class RouteAPI {
+  current: string;
+  status: number;
+  url: string;
+  constructor(entryName: string);
+  redirect(url: string, status?: number): void;
+  rewrite(entryName: string): void;
+  use(entryName: string): void;
+}

package/dist/types/libs/hook-api/template.d.ts CHANGED Viewed

@@ -1,14 +1,24 @@
-declare class TemplateAPI {
+/// <reference types="node" />
+import { Transform } from 'stream';
+export declare class TemplateAPI {
   private content;
   constructor(content: string);
   get(): string;
   set(content: string): void;
-  prependHead(fragment: string): this;
-  appendHead(fragment: string): this;
-  prependBody(fragment: string): this;
-  appendBody(fragment: string): this;
-  replace(reg: RegExp | string, text: string): this;
+  prependHead(fragment: string): void;
+  appendHead(fragment: string): void;
+  prependBody(fragment: string): void;
+  appendBody(fragment: string): void;
+  private replace;
 }
-export declare const createTemplateAPI: (content: string) => TemplateAPI;
-export {};
+export declare const templateInjectableStream: ({
+  prependHead,
+  appendHead,
+  prependBody,
+  appendBody
+}: {
+  prependHead?: string | undefined;
+  appendHead?: string | undefined;
+  prependBody?: string | undefined;
+  appendBody?: string | undefined;
+}) => Transform;

package/dist/types/libs/render/cache/index.d.ts CHANGED Viewed

@@ -1,6 +1,8 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
 import type { ModernServerContext } from '@modern-js/types';
-import { RenderFunction } from '../type';
+import { RenderFunction, SSRServerContext } from '../type';
-declare const _default: (renderFn: RenderFunction, ctx: ModernServerContext) => RenderFunction;
+declare const _default: (renderFn: RenderFunction, ctx: ModernServerContext) => (context: SSRServerContext) => Promise<string | Readable>;
 export default _default;

package/dist/types/libs/render/type.d.ts CHANGED Viewed

@@ -1,4 +1,6 @@
 /// <reference types="react" />
+/// <reference types="node" />
+import { Writable, Readable } from 'stream';
 import { BaseSSRServerContext } from '@modern-js/types';
 declare type MetaKeyMap = {
   header?: string[];
@@ -30,5 +32,5 @@ export declare type ModernSSRReactComponent = React.ComponentType<any> & {
   init: (context: SSRServerContext) => Promise<void>;
   prefetch: (context: SSRServerContext) => Promise<Record<string, any>>;
 };
-export declare type RenderFunction = (context: SSRServerContext) => Promise<string>;
+export declare type RenderFunction = (context: SSRServerContext) => Promise<string | ((writable: Writable) => Promise<Readable>)>;
 export {};

package/dist/types/libs/route/route.d.ts CHANGED Viewed

@@ -8,7 +8,6 @@ export declare class ModernRoute implements ModernRouteInterface {
   isApi: boolean;
   isSSR: boolean;
   isSPA: boolean;
-  enableModernMode?: boolean;
   params: Record<string, any>;
   responseHeaders?: Record<string, any>;
   constructor(routeSpec: ModernRouteInterface);

package/dist/types/libs/serve-file.d.ts CHANGED Viewed

@@ -1,9 +1,10 @@
 import { ServerOptions } from '@modern-js/server-core';
 import type { ModernServerContext } from '@modern-js/types';
-import { NextFunction } from '../type';
+import { NextFunction, ModernServerHandler } from '../type';
 declare type Rule = {
   path: string | RegExp;
   target: string;
 };
+export declare const faviconFallbackHandler: ModernServerHandler;
 export declare const createStaticFileHandler: (rules: Rule[], output?: ServerOptions['output']) => (context: ModernServerContext, next: NextFunction) => Promise<void>;
 export {};

package/dist/types/server/index.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { IncomingMessage, ServerResponse } from 'http';
 import type { ListenOptions } from 'net';
 import { ModernServerOptions, ServerConstructor } from '../type';
@@ -44,6 +45,7 @@ export declare class Server {
   close(): Promise<void>;
   listen<T extends number | ListenOptions | undefined>(options: T, listener: any): void;
   getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
+  render(req: IncomingMessage, res: ServerResponse, url?: string): Promise<string | null>;
   private createHookRunner;
   private injectContext;
   private initAppContext;

package/dist/types/server/modern-server.d.ts CHANGED Viewed

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 import { IncomingMessage, ServerResponse, Server } from 'http';
-import { Adapter, APIServerStartInput, ServerOptions } from '@modern-js/server-core';
-import type { ModernServerContext } from '@modern-js/types';
+import { Adapter, WebAdapter, APIServerStartInput, ServerOptions } from '@modern-js/server-core';
+import type { ModernServerContext, ServerRoute } from '@modern-js/types';
 import type { ContextOptions } from '../libs/context';
-import { ModernServerOptions, NextFunction, ServerHookRunner, Metrics, Logger, ModernServerInterface, HookNames, BuildOptions, ModernServerHandler } from '../type';
+import { ModernServerOptions, NextFunction, ServerHookRunner, Metrics, Logger, ModernServerInterface, BuildOptions, ModernServerHandler } from '../type';
 import { RouteMatchManager, ModernRouteInterface, ModernRoute } from '../libs/route';
 import { mergeExtension } from '../utils';
 import * as reader from '../libs/render/reader';
@@ -24,6 +24,7 @@ export declare class ModernServer implements ModernServerInterface {
   protected readonly proxyTarget: ModernServerOptions['proxyTarget'];
   private staticFileHandler;
   private routeRenderHandler;
+  private beforeRouteHandler;
   private frameWebHandler;
   private frameAPIHandler;
   private proxyHandler;
@@ -41,27 +42,26 @@ export declare class ModernServer implements ModernServerInterface {
   }: ModernServerOptions);
   onInit(runner: ServerHookRunner, app: Server): Promise<void>;
   onRepack(_: BuildOptions): void;
+  addBeforeRouteHandler(): void;
   protected onServerChange({
     filepath
   }: {
     filepath: string;
   }): void;
   getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void | ServerResponse;
+  render(req: IncomingMessage, res: ServerResponse, url?: string): Promise<string | null>;
   createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server>;
-  protected getRoutes(): ModernRouteInterface[];
+  protected getRoutes(): ServerRoute[];
   protected addHandler(handler: ModernServerHandler): void;
   protected render404(context: ModernServerContext): void;
+  protected prepareBeforeRouteHandler(specs: ServerRoute[], distDir: string): Promise<void>;
   protected prepareFrameHandler(options?: {
     onlyApi: boolean;
     onlyWeb: boolean;
   }): Promise<void>;
-  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<Adapter>;
+  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<WebAdapter>;
   protected prepareAPIHandler(extension: APIServerStartInput['config']): Promise<Adapter>;
-  protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
-  protected emitRouteHook(eventName: HookNames, input: {
-    context: ModernServerContext;
-    [propsName: string]: any;
-  }): Promise<any>;
+  protected filterRoutes(routes: ModernRouteInterface[]): ServerRoute[];
   protected setupBeforeProdMiddleware(): Promise<void>;
   protected handleAPI(context: ModernServerContext): Promise<void>;
   protected handleWeb(context: ModernServerContext, route: ModernRoute): Promise<import("../type").RenderResult | null>;
@@ -70,9 +70,9 @@ export declare class ModernServer implements ModernServerInterface {
   protected createContext(req: IncomingMessage, res: ServerResponse, options?: ContextOptions): import("../libs/context").ModernServerContext;
   private routeHandler;
   private isSend;
-  private injectMicroFE;
   private compose;
   private requestHandler;
+  private redirect;
   private onError;
   private renderErrorPage;
 }

package/dist/types/type.d.ts CHANGED Viewed

@@ -1,9 +1,11 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { IncomingMessage, Server, ServerResponse } from 'http';
+import { Readable } from 'stream';
 import { serverManager, ServerOptions } from '@modern-js/server-core';
 import type { ServerPlugin } from '@modern-js/server-core';
-import type { Metrics, Logger, NextFunction, ModernServerContext } from '@modern-js/types';
+import type { Metrics, Logger, NextFunction, ModernServerContext, InternalPlugins } from '@modern-js/types';
 import type { ModernRouteInterface } from './libs/route';
 declare module 'http' {
   interface IncomingMessage {
@@ -11,30 +13,25 @@ declare module 'http' {
     metrics: Metrics;
   }
 }
-declare type Plugin = string | [string, any] | ServerPlugin;
 export declare type ModernServerOptions = {
   pwd: string;
   config: ServerOptions;
-  plugins?: Plugin[];
+  plugins?: ServerPlugin[];
+  internalPlugins?: InternalPlugins;
   routes?: ModernRouteInterface[];
   staticGenerate?: boolean;
-  loggerOptions?: Record<string, string>;
-  metricsOptions?: Record<string, string>;
   logger?: Logger;
   metrics?: Metrics;
   apiOnly?: boolean;
   ssrOnly?: boolean;
   webOnly?: boolean;
-  proxyTarget?: {
-    ssr?: string;
-    api?: string;
-  };
   runMode?: string;
   [propName: string]: any;
 };
 export declare type RenderResult = {
   content: string | Buffer;
   contentType: string;
+  contentStream?: Readable;
   statusCode?: number;
   redirect?: boolean;
 };
@@ -49,7 +46,7 @@ export declare type BuildOptions = {
   routes?: ModernRouteInterface[];
 };
 export type { Metrics, Logger, NextFunction };
-export declare type HookNames = 'beforeMatch' | 'afterMatch' | 'beforeRender' | 'afterRender';
+export declare type HookNames = 'afterMatch' | 'afterRender';
 export interface ModernServerInterface {
   pwd: string;
   distDir: string;
@@ -57,6 +54,7 @@ export interface ModernServerInterface {
   onRepack: (options: BuildOptions) => void;
   getRequestHandler: () => (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
   createHTTPServer: (handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void) => Promise<Server>;
+  render: (req: IncomingMessage, res: ServerResponse, url?: string) => Promise<string | null>;
 }
 export declare type ServerConstructor = (options: ModernServerOptions) => ModernServerInterface;
 export declare type ModernServerHandler = (context: ModernServerContext, next: NextFunction) => Promise<void> | void;

package/dist/types/utils.d.ts CHANGED Viewed

@@ -1,8 +1,8 @@
-/// <reference path="type.d.ts" />
 /// <reference types="node" />
 /// <reference types="node/http" />
+/// <reference types=".dts-temp/8-abj5cxwfao2-yqb9uay/src/type" />
 import { IncomingMessage } from 'http';
-import type { NormalizedConfig } from '@modern-js/core';
+import type { OutputNormalizedConfig, HtmlNormalizedConfig } from '@modern-js/server-core';
 export declare const debug: any;
 export declare const mergeExtension: (users: any[]) => {
   middleware: any[];
@@ -18,9 +18,8 @@ export declare const createMiddlewareCollecter: () => {
   addWebMiddleware: (input: any) => void;
   addAPIMiddleware: (input: any) => void;
 };
-export declare const toPath: (reg: string, params: Record<string, any>) => string;
 export declare const useLocalPrefix: (url: string) => boolean;
-export declare const getStaticReg: (output?: NormalizedConfig['output']) => RegExp;
+export declare const getStaticReg: (output?: OutputNormalizedConfig, html?: HtmlNormalizedConfig) => RegExp;
 export declare const prepareFavicons: (favicon: string | undefined, faviconByEntries?: Record<string, string | undefined>) => string[];
 export declare const headersWithoutCookie: (headers: IncomingMessage['headers']) => import("http").IncomingHttpHeaders;
 export declare const isRedirect: (code: number) => boolean;

package/dist/types/worker-server.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+import { ModernRouteInterface } from './libs/route';
+export declare type Context = Record<string, any>;
+export interface UrlQuery {
+  [key: string]: string;
+}
+export declare type Manifest = {
+  pages: Record<string, // path
+  {
+    entryName: string;
+    template: string;
+    serverRender: (ctx: Record<string, any>) => Promise<string>;
+  }>;
+  routes: ModernRouteInterface[];
+};
+export declare const createHandler: (manifest: Manifest) => (ctx: Context) => Promise<void>;