@modern-js/server-core 2.54.6 → 2.55.0

package/dist/esm-node/plugins/render/ssrRender.js

@@ -1,30 +1,13 @@
-import { SERVER_RENDER_FUNCTION_NAME, MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-import * as isbot from "isbot";
-import { getRuntimeEnv, parseHeaders, parseQuery, getHost, getPathname } from "../../utils";
-import { X_MODERNJS_RENDER, X_RENDER_CACHE } from "../../constants";
-import { ServerTiming } from "./serverTiming";
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import { parseHeaders, getPathname } from "../../utils";
+import { X_MODERNJS_RENDER } from "../../constants";
 import { matchCacheControl, getCacheResult } from "./ssrCache";
-const defaultReporter = {
-  init() {
-  },
-  reportError() {
-  },
-  reportTiming() {
-  },
-  reportInfo() {
-  },
-  reportWarn() {
-  }
-};
-async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, cacheConfig }) {
+const SERVER_RUNTIME_ENTRY = "requestHandler";
+async function ssrRender(request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, locals, params, loaderContext, reporter, cacheConfig, logger, metrics, onError, onTiming }) {
   var _serverManifest_renderBundles;
   const { entryName } = routeInfo;
   const loadableStats = serverManifest.loadableStats || {};
   const routeManifest = serverManifest.routeManifest || {};
-  const host = getHost(request);
-  const isSpider = isbot.default(request.headers.get("user-agent"));
-  const responseProxy = new ResponseProxy();
-  const query = parseQuery(request);
   const headers = parseHeaders(request);
   if (nodeReq) {
     for (const key in nodeReq.headers) {
@@ -33,103 +16,46 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
       }
     }
   }
-  const ssrContext = {
-    request: {
-      baseUrl: routeInfo.urlPath,
-      params,
-      pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : getPathname(request),
-      host,
-      query,
-      url: nodeReq ? getHrefFromNodeReq(nodeReq) : request.url,
-      headers
-    },
-    response: {
-      setHeader(key, value) {
-        responseProxy.headers.set(key, value);
-      },
-      status(code) {
-        responseProxy.status = code;
-      },
-      locals: locals || {}
+  const renderBundle = (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[entryName || MAIN_ENTRY_NAME];
+  if (!renderBundle) {
+    throw new Error(`Can't found renderBundle ${entryName || MAIN_ENTRY_NAME}`);
+  }
+  const requestHandler = await renderBundle[SERVER_RUNTIME_ENTRY];
+  const config = createRequestHandlerConfig(userConfig);
+  const requestHandlerOptions = {
+    resource: {
+      route: routeInfo,
+      loadableStats,
+      routeManifest,
+      htmlTemplate: html,
+      entryName: entryName || MAIN_ENTRY_NAME
     },
-    redirection: {},
-    template: html,
-    loadableStats,
+    params,
     loaderContext,
-    routeManifest,
-    entryName,
+    config,
+    locals,
+    reporter,
     staticGenerate,
     logger,
     metrics,
-    serverTiming: new ServerTiming(responseProxy.headers, metaName),
-    reporter: reporter || defaultReporter,
-    /** @deprecated node req */
-    req: nodeReq || request,
-    /** @deprecated node res  */
-    res: void 0,
-    isSpider,
-    nonce
+    onError,
+    onTiming
   };
-  const renderBundle = (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[entryName || MAIN_ENTRY_NAME];
-  if (!renderBundle) {
-    throw new Error(`Can't found renderBundle ${entryName || MAIN_ENTRY_NAME}`);
-  }
-  const runtimeEnv = getRuntimeEnv();
-  let ssrResult;
-  let cacheStatus;
-  const render = renderBundle[SERVER_RENDER_FUNCTION_NAME];
   const cacheControl = await matchCacheControl(cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.strategy, nodeReq || new IncomingMessgeProxy(request));
+  let response;
   if (cacheControl) {
-    const { data: data2, status } = await getCacheResult(request, {
+    response = await getCacheResult(request, {
       cacheControl,
       container: cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.container,
-      render,
-      ssrContext
+      requestHandler,
+      requestHandlerOptions
     });
-    ssrResult = data2;
-    cacheStatus = status;
   } else {
-    ssrResult = await render(ssrContext);
-  }
-  const { redirection } = ssrContext;
-  if (cacheStatus) {
-    responseProxy.headers.set(X_RENDER_CACHE, cacheStatus);
-  }
-  responseProxy.headers.set(X_MODERNJS_RENDER, "server");
-  if (redirection.url) {
-    const { headers: headers2 } = responseProxy;
-    headers2.set("Location", redirection.url);
-    return new Response(null, {
-      status: redirection.status || 302,
-      headers: {
-        Location: redirection.url
-      }
-    });
-  }
-  const { Readable } = await import("stream").catch((_) => ({
-    Readable: void 0
-  }));
-  const streamModule = "../../adapters/node/polyfills/stream";
-  const { createReadableStreamFromReadable } = runtimeEnv === "node" ? await import(streamModule).catch((_) => ({
-    createReadableStreamFromReadable: void 0
-  })) : {
-    createReadableStreamFromReadable: void 0
-  };
-  const data = Readable && ssrResult instanceof Readable ? (createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(ssrResult)) || "" : ssrResult;
-  if (typeof data !== "string") {
-    responseProxy.headers.set("transfer-encoding", "chunked");
-  }
-  return new Response(data, {
-    status: responseProxy.status,
-    headers: responseProxy.headers
-  });
-}
-class ResponseProxy {
-  constructor() {
-    this.headers = new Headers();
-    this.status = 200;
-    this.headers.set("content-type", "text/html; charset=UTF-8");
+    response = await requestHandler(request, requestHandlerOptions);
   }
+  response.headers.set(X_MODERNJS_RENDER, "server");
+  response.headers.set("content-type", "text/html; charset=UTF-8");
+  return response;
 }
 class IncomingMessgeProxy {
   constructor(req) {
@@ -141,38 +67,18 @@ class IncomingMessgeProxy {
     this.url = getPathname(req);
   }
 }
-function getHrefFromNodeReq(nodeReq) {
-  function getProtocal() {
-    if (nodeReq.socket.encrypted) {
-      return "https";
-    }
-    const proto = nodeReq.headers["x-forwarded-proto"];
-    return proto ? proto.split(/\s*,\s*/, 1)[0] : "http";
-  }
-  function getHost2() {
-    let host = nodeReq.headers["x-forwarded-host"];
-    if (!host) {
-      host = nodeReq.headers.host;
-    }
-    host = host.split(/\s*,\s*/, 1)[0] || "undefined";
-    return host;
-  }
-  const href = `${getProtocal()}://${getHost2()}${nodeReq.url || ""}`;
-  return href;
-}
-function getPathnameFromNodeReq(nodeReq) {
-  const { url } = nodeReq;
-  if (!url) {
-    return "/";
-  }
-  const match = url.match(/\/[^?]*/);
-  let pathname = match ? match[0] : "/";
-  if (pathname !== "/" && pathname.endsWith("/")) {
-    pathname = pathname.slice(0, -1);
-  }
-  return pathname;
+function createRequestHandlerConfig(userConfig) {
+  const { output, server, security, html } = userConfig;
+  return {
+    ssr: server === null || server === void 0 ? void 0 : server.ssr,
+    ssrByEntries: server === null || server === void 0 ? void 0 : server.ssrByEntries,
+    nonce: security === null || security === void 0 ? void 0 : security.nonce,
+    enableInlineScripts: output === null || output === void 0 ? void 0 : output.enableInlineScripts,
+    enableInlineStyles: output === null || output === void 0 ? void 0 : output.enableInlineStyles,
+    crossorigin: html === null || html === void 0 ? void 0 : html.crossorigin,
+    scriptLoading: html === null || html === void 0 ? void 0 : html.scriptLoading
+  };
 }
 export {
-  getPathnameFromNodeReq,
   ssrRender
 };

package/dist/esm-node/utils/transformStream.js

@@ -4,7 +4,7 @@ function createTransformStream(fn) {
   return new TransformStream({
     async transform(chunk, controller) {
       const content = decoder.decode(chunk);
-      const newContent = await fn(content);
+      const newContent = fn ? await fn(content) : content;
       controller.enqueue(encoder.encode(newContent));
     }
   });

package/dist/types/index.d.ts

@@ -9,3 +9,4 @@ export * from './types/plugin';
 export * from './types/render';
 export * from '@modern-js/plugin';
 export * from './types/config';
+export * from './types/requestHandler';

package/dist/types/plugins/render/dataHandler.d.ts

@@ -1,5 +1,5 @@
 import type { ServerRoute } from '@modern-js/types';
 import { SSRRenderOptions } from './ssrRender';
-export declare const dataHandler: (request: Request, { routeInfo, serverRoutes, reporter, logger, serverManifest, }: SSRRenderOptions & {
+export declare const dataHandler: (request: Request, { routeInfo, serverRoutes, reporter, onError, onTiming, serverManifest, }: SSRRenderOptions & {
     serverRoutes: ServerRoute[];
 }) => Promise<Response | void>;

package/dist/types/plugins/render/render.d.ts

@@ -1,5 +1,5 @@
 import { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
-import type { CacheConfig, FallbackReason } from '../../types';
+import type { CacheConfig, FallbackReason, UserConfig } from '../../types';
 import { Render } from '../../types';
 export type OnFallback = (reason: FallbackReason, utils: {
     logger: Logger;
@@ -9,6 +9,7 @@ export type OnFallback = (reason: FallbackReason, utils: {
 interface CreateRenderOptions {
     pwd: string;
     routes: ServerRoute[];
+    config: UserConfig;
     cacheConfig?: CacheConfig;
     staticGenerate?: boolean;
     onFallback?: OnFallback;
@@ -16,5 +17,5 @@ interface CreateRenderOptions {
     forceCSR?: boolean;
     nonce?: string;
 }
-export declare function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, nonce, onFallback: onFallbackFn, }: CreateRenderOptions): Promise<Render>;
+export declare function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, config, onFallback: onFallbackFn, }: CreateRenderOptions): Promise<Render>;
 export {};

package/dist/types/plugins/render/serverTiming.d.ts

@@ -1,7 +1,8 @@
 import { ServerTiming as ServerTimingInterafce } from '@modern-js/types';
 export declare class ServerTiming implements ServerTimingInterafce {
-    private headers;
+    private headerList;
     private meta;
-    constructor(headers: Headers, meta: string);
+    constructor(meta: string);
+    get headers(): string[];
     addServeTiming(name: string, dur: number, desc?: string): this;
 }

package/dist/types/plugins/render/ssrCache.d.ts

@@ -1,19 +1,15 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import type { IncomingMessage } from 'http';
-import type * as nodeStream from 'stream';
 import type { CacheControl, CacheOption, Container } from '@modern-js/types';
-import type { SSRServerContext, ServerRender } from '../../types';
+import { RequestHandler, RequestHandlerOptions } from '../../types/requestHandler';
 export type CacheStatus = 'hit' | 'stale' | 'expired' | 'miss';
-export type CacheResult = {
-    data: string | nodeStream.Readable | ReadableStream;
-    status?: CacheStatus;
-};
-export declare function matchCacheControl(cacheOption?: CacheOption, req?: IncomingMessage): CacheControl | Promise<CacheControl> | undefined;
+type MaybeAsync<T> = Promise<T> | T;
+export declare function matchCacheControl(cacheOption?: CacheOption, req?: IncomingMessage): MaybeAsync<CacheControl | undefined | false>;
 export interface GetCacheResultOptions {
     cacheControl: CacheControl;
-    render: ServerRender;
-    ssrContext: SSRServerContext;
+    requestHandler: RequestHandler;
+    requestHandlerOptions: RequestHandlerOptions;
     container?: Container;
 }
-export declare function getCacheResult(request: Request, options: GetCacheResultOptions): Promise<CacheResult>;
+export declare function getCacheResult(request: Request, options: GetCacheResultOptions): Promise<Response>;
+export {};

package/dist/types/plugins/render/ssrRender.d.ts

@@ -1,25 +1,25 @@
 /// <reference types="node" />
 import type { IncomingMessage } from 'http';
-import type { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
-import { CacheConfig, ServerManifest } from '../../types';
-export type Params = Record<string, any>;
+import type { Reporter, ServerRoute, Logger, Metrics } from '@modern-js/types';
+import { OnError, OnTiming, Params } from '../../types/requestHandler';
+import { CacheConfig, ServerManifest, UserConfig } from '../../types';
 export interface SSRRenderOptions {
     pwd: string;
     html: string;
     routeInfo: ServerRoute;
     staticGenerate: boolean;
-    metaName: string;
-    logger: Logger;
+    config: UserConfig;
     serverManifest: ServerManifest;
     loaderContext: Map<string, unknown>;
     params: Params;
+    logger: Logger;
+    metrics?: Metrics;
+    reporter?: Reporter;
     /** Produce by custom server hook */
     locals?: Record<string, any>;
     cacheConfig?: CacheConfig;
-    reporter?: Reporter;
-    metrics?: Metrics;
     nodeReq?: IncomingMessage;
-    nonce?: string;
+    onError?: OnError;
+    onTiming?: OnTiming;
 }
-export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, cacheConfig, }: SSRRenderOptions): Promise<Response>;
-export declare function getPathnameFromNodeReq(nodeReq: IncomingMessage): string;
+export declare function ssrRender(request: Request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, locals, params, loaderContext, reporter, cacheConfig, logger, metrics, onError, onTiming, }: SSRRenderOptions): Promise<Response>;

package/dist/types/types/config/html.d.ts

@@ -1,5 +1,16 @@
+export type CrossOrigin = 'anonymous' | 'use-credentials';
+export type ScriptLoading = 'defer' | 'module' | 'blocking';
 export interface HtmlUserConfig {
     favicon?: string;
     faviconByEntries?: Record<string, string | undefined>;
+    /**
+     * Set the [crossorigin](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/crossorigin) attribute
+     * of the `<script>` tag.
+     */
+    crossorigin?: boolean | CrossOrigin;
+    /**
+     * Set the loading mode of the `<script>` tag.
+     */
+    scriptLoading?: ScriptLoading;
 }
 export type HtmlNormalizedConfig = HtmlUserConfig;

package/dist/types/types/config/output.d.ts

@@ -15,5 +15,13 @@ export interface OutputUserConfig {
     path?: string;
     assetPrefix?: string;
     polyfill?: 'entry' | 'usage' | 'ua' | 'off';
+    /**
+     * @deprecated use `output.inlineScripts` instead
+     */
+    enableInlineScripts?: boolean;
+    /**
+     * @deprecated use `output.inlineStyles` instead
+     */
+    enableInlineStyles?: boolean;
 }
 export type OutputNormalizedConfig = OutputUserConfig;

package/dist/types/types/requestHandler.d.ts

@@ -0,0 +1,43 @@
+import { Metrics, Reporter, ServerRoute, Logger } from '@modern-js/types';
+import { ServerUserConfig } from './config';
+export type Resource = {
+    loadableStats: Record<string, any>;
+    routeManifest: Record<string, any>;
+    route: ServerRoute;
+    htmlTemplate: string;
+    entryName: string;
+};
+export type Params = Record<string, any>;
+export type RequestHandlerConfig = {
+    nonce?: string;
+    crossorigin?: boolean | 'anonymous' | 'use-credentials';
+    scriptLoading?: 'defer' | 'blocking' | 'module' | 'async';
+    enableInlineStyles?: boolean | RegExp;
+    enableInlineScripts?: boolean | RegExp;
+    disablePrerender?: boolean;
+    chunkLoadingGlobal?: string;
+    ssr?: ServerUserConfig['ssr'];
+    ssrByEntries?: ServerUserConfig['ssrByEntries'];
+};
+export type LoaderContext = Map<string, any>;
+export type OnError = (err: unknown) => void;
+export type OnTiming = (name: string, dur: number) => void;
+export type RequestHandlerOptions = {
+    resource: Resource;
+    config: RequestHandlerConfig;
+    params: Params;
+    loaderContext: LoaderContext;
+    /** @deprecated  */
+    locals?: Record<string, any>;
+    /** @deprecated  */
+    staticGenerate?: boolean;
+    /** @deprecated ssr runtime code need reporter instance */
+    reporter?: Reporter;
+    /** @deprecated */
+    logger: Logger;
+    /** @deprecated */
+    metrics?: Metrics;
+    onError?: OnError;
+    onTiming?: OnTiming;
+};
+export type RequestHandler = (request: Request, options: RequestHandlerOptions) => Promise<Response>;

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

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import type { Readable } from 'node:stream';
 import type { Metrics, Logger, Reporter, BaseSSRServerContext, ServerRoute, NestedRoute } from '@modern-js/types';
+import { RequestHandler as BundleRequestHandler, OnError, OnTiming } from './requestHandler';
 export type SSRServerContext = BaseSSRServerContext & {
     staticGenerate?: boolean;
 };
@@ -11,12 +12,16 @@ type ServerLoaderBundle = {
     handleRequest: (options: {
         request: Request;
         serverRoutes: ServerRoute[];
-        context: any;
         routes: NestedRoute[];
+        context: {
+            reporter?: Reporter;
+        };
+        onError?: OnError;
+        onTiming?: OnTiming;
     }) => Promise<any>;
 };
 type ServerRenderBundle = {
-    serverRender: () => any;
+    requestHandler: Promise<BundleRequestHandler>;
 };
 export type ServerManifest = {
     loaderBundles?: Record<string, ServerLoaderBundle>;

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

@@ -1,5 +1,5 @@
 import { MaybeAsync } from '@modern-js/plugin';
 type TransformCb = (tempalte: string) => MaybeAsync<string>;
-export declare function createTransformStream(fn: TransformCb): TransformStream<any, any>;
+export declare function createTransformStream(fn?: TransformCb): TransformStream<any, any>;
 export declare function transformResponse(response: Response, transformCb: Array<TransformCb> | TransformCb): Response;
 export {};

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.54.6",
+  "version": "2.55.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -52,10 +52,9 @@
     "@web-std/file": "^3.0.3",
     "hono": "^3.12.2",
     "ts-deepmerge": "7.0.0",
-    "isbot": "3.8.0",
-    "@modern-js/plugin": "2.54.6",
-    "@modern-js/runtime-utils": "2.54.6",
-    "@modern-js/utils": "2.54.6"
+    "@modern-js/plugin": "2.55.0",
+    "@modern-js/runtime-utils": "2.55.0",
+    "@modern-js/utils": "2.55.0"
   },
   "devDependencies": {
     "@types/jest": "^29",
@@ -65,9 +64,9 @@
     "jest": "^29",
     "ts-jest": "^29.1.0",
     "typescript": "^5",
-    "@scripts/build": "2.54.6",
-    "@scripts/jest-config": "2.54.6",
-    "@modern-js/types": "2.54.6"
+    "@modern-js/types": "2.55.0",
+    "@scripts/jest-config": "2.55.0",
+    "@scripts/build": "2.55.0"
   },
   "sideEffects": false,
   "publishConfig": {