@modern-js/prod-server 2.43.0 → 2.44.0

package/dist/cjs/libs/hook-api/afterRenderForStream.js

@@ -0,0 +1,34 @@
+"use strict";
+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);
+var afterRenderForStream_exports = {};
+__export(afterRenderForStream_exports, {
+  afterRenderInjectableStream: () => afterRenderInjectableStream
+});
+module.exports = __toCommonJS(afterRenderForStream_exports);
+var import_stream = require("stream");
+const afterRenderInjectableStream = (fn) => new import_stream.Transform({
+  async write(chunk, _, callback) {
+    this.push(await fn(chunk.toString()));
+    callback();
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  afterRenderInjectableStream
+});

package/dist/cjs/libs/hook-api/index.js

@@ -21,6 +21,7 @@ __export(hook_api_exports, {
   base: () => base,
   createAfterMatchContext: () => createAfterMatchContext,
   createAfterRenderContext: () => createAfterRenderContext,
+  createAfterStreamingRenderContext: () => createAfterStreamingRenderContext,
   createMiddlewareContext: () => createMiddlewareContext
 });
 module.exports = __toCommonJS(hook_api_exports);
@@ -51,6 +52,16 @@ const createAfterRenderContext = (context, route, content) => {
     template: new import_template.TemplateAPI(content)
   };
 };
+const createAfterStreamingRenderContext = (context, route) => {
+  const baseContext = base(context);
+  return (chunk) => {
+    return {
+      ...baseContext,
+      route,
+      chunk
+    };
+  };
+};
 const createMiddlewareContext = (context) => {
   const baseContext = base(context);
   baseContext.response.locals = context.res.locals || {};
@@ -69,5 +80,6 @@ const createMiddlewareContext = (context) => {
   base,
   createAfterMatchContext,
   createAfterRenderContext,
+  createAfterStreamingRenderContext,
   createMiddlewareContext
 });

package/dist/cjs/libs/render/index.js

@@ -74,9 +74,7 @@ const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, s
       }
       const ssrRenderOptions = {
         distDir,
-        entryName: route.entryName,
-        urlPath: route.urlPath,
-        bundle: route.bundle,
+        route,
         template: content.toString(),
         staticGenerate,
         nonce

package/dist/cjs/libs/render/ssr.js

@@ -33,12 +33,15 @@ __export(ssr_exports, {
 module.exports = __toCommonJS(ssr_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
+var import_hook_api = require("../hook-api");
+var import_afterRenderForStream = require("../hook-api/afterRenderForStream");
 var import_measure = require("./measure");
 var import_utils2 = require("./utils");
 var import_ssrCache = require("./ssrCache");
 const render = async (ctx, renderOptions, runner) => {
   var _ctx_res;
-  const { urlPath, bundle, distDir, template, entryName, staticGenerate, enableUnsafeCtx = false, nonce } = renderOptions;
+  const { distDir, route, template, staticGenerate, enableUnsafeCtx = false, nonce } = renderOptions;
+  const { urlPath, bundle, entryName } = route;
   const bundleJS = import_path.default.join(distDir, bundle);
   const loadableUri = import_path.default.join(distDir, import_utils.LOADABLE_STATS_FILE);
   const loadableStats = import_utils.fs.existsSync(loadableUri) ? require(loadableUri) : "";
@@ -99,9 +102,17 @@ const render = async (ctx, renderOptions, runner) => {
       contentType: import_utils.mime.contentType("html")
     };
   } else {
+    let contentStream = (0, import_utils2.injectServerDataStream)(content, ctx);
+    const afterStreamingRenderContext = (0, import_hook_api.createAfterStreamingRenderContext)(ctx, route);
+    contentStream = contentStream.pipe((0, import_afterRenderForStream.afterRenderInjectableStream)((chunk) => {
+      const context2 = afterStreamingRenderContext(chunk);
+      return runner.afterStreamingRender(context2, {
+        onLast: ({ chunk: chunk2 }) => chunk2
+      });
+    }));
     return {
       content: "",
-      contentStream: (0, import_utils2.injectServerDataStream)(content, ctx),
+      contentStream,
       contentType: import_utils.mime.contentType("html")
     };
   }

package/dist/cjs/libs/render/ssrCache/manager.js

@@ -26,7 +26,7 @@ var import_stream = require("stream");
 class CacheManager {
   async getCacheResult(req, cacheControl, render, ssrContext) {
     const key = this.computedKey(req, cacheControl);
-    const value = await this.containter.get(key);
+    const value = await this.container.get(key);
     const { maxAge, staleWhileRevalidate } = cacheControl;
     const ttl = maxAge + staleWhileRevalidate;
     if (value) {
@@ -52,7 +52,7 @@ class CacheManager {
         val: renderResult,
         cursor: current
       };
-      await this.containter.set(key, JSON.stringify(cache), {
+      await this.container.set(key, JSON.stringify(cache), {
         ttl
       });
       return renderResult;
@@ -71,7 +71,7 @@ class CacheManager {
           val: html,
           cursor: current
         };
-        this.containter.set(key, JSON.stringify(cache), {
+        this.container.set(key, JSON.stringify(cache), {
           ttl
         });
       });
@@ -93,9 +93,9 @@ class CacheManager {
       return defaultKey;
     }
   }
-  constructor(containter) {
-    (0, import_define_property._)(this, "containter", void 0);
-    this.containter = containter;
+  constructor(container) {
+    (0, import_define_property._)(this, "container", void 0);
+    this.container = container;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/esm/libs/hook-api/afterRenderForStream.js

@@ -0,0 +1,33 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { Transform } from "stream";
+var afterRenderInjectableStream = function(fn) {
+  return new Transform({
+    write: function write(chunk, _, callback) {
+      return _async_to_generator(function() {
+        var _2, _1;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              _1 = (_2 = this).push;
+              return [
+                4,
+                fn(chunk.toString())
+              ];
+            case 1:
+              _1.apply(_2, [
+                _state.sent()
+              ]);
+              callback();
+              return [
+                2
+              ];
+          }
+        });
+      }).apply(this);
+    }
+  });
+};
+export {
+  afterRenderInjectableStream
+};

package/dist/esm/libs/hook-api/index.js

@@ -25,6 +25,15 @@ var createAfterRenderContext = function(context, route, content) {
     template: new TemplateAPI(content)
   });
 };
+var createAfterStreamingRenderContext = function(context, route) {
+  var baseContext = base(context);
+  return function(chunk) {
+    return _object_spread_props(_object_spread({}, baseContext), {
+      route,
+      chunk
+    });
+  };
+};
 var createMiddlewareContext = function(context) {
   var baseContext = base(context);
   baseContext.response.locals = context.res.locals || {};
@@ -41,5 +50,6 @@ export {
   base,
   createAfterMatchContext,
   createAfterRenderContext,
+  createAfterStreamingRenderContext,
   createMiddlewareContext
 };

package/dist/esm/libs/render/index.js

@@ -97,9 +97,7 @@ var createRenderHandler = function(param) {
           case 6:
             ssrRenderOptions = {
               distDir,
-              entryName: route.entryName,
-              urlPath: route.urlPath,
-              bundle: route.bundle,
+              route,
               template: content.toString(),
               staticGenerate,
               nonce

package/dist/esm/libs/render/ssr.js

@@ -2,16 +2,19 @@ import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { fs, mime, LOADABLE_STATS_FILE, ROUTE_MANIFEST_FILE, SERVER_RENDER_FUNCTION_NAME } from "@modern-js/utils";
+import { createAfterStreamingRenderContext } from "../hook-api";
+import { afterRenderInjectableStream } from "../hook-api/afterRenderForStream";
 import { createLogger, createMetrics } from "./measure";
 import { injectServerDataStream, injectServerData } from "./utils";
 import { ssrCache } from "./ssrCache";
 var render = function() {
   var _ref = _async_to_generator(function(ctx, renderOptions, runner) {
-    var _ctx_res, urlPath, bundle, distDir, template, entryName, staticGenerate, _renderOptions_enableUnsafeCtx, enableUnsafeCtx, nonce, bundleJS, loadableUri, loadableStats, routesManifestUri, routeManifest, context, bundleJSContent, serverRender, content, _context_redirection, url, _context_redirection_status, status;
+    var _ctx_res, distDir, route, template, staticGenerate, _renderOptions_enableUnsafeCtx, enableUnsafeCtx, nonce, urlPath, bundle, entryName, bundleJS, loadableUri, loadableStats, routesManifestUri, routeManifest, context, bundleJSContent, serverRender, content, _context_redirection, url, _context_redirection_status, status, contentStream, afterStreamingRenderContext;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          urlPath = renderOptions.urlPath, bundle = renderOptions.bundle, distDir = renderOptions.distDir, template = renderOptions.template, entryName = renderOptions.entryName, staticGenerate = renderOptions.staticGenerate, _renderOptions_enableUnsafeCtx = renderOptions.enableUnsafeCtx, enableUnsafeCtx = _renderOptions_enableUnsafeCtx === void 0 ? false : _renderOptions_enableUnsafeCtx, nonce = renderOptions.nonce;
+          distDir = renderOptions.distDir, route = renderOptions.route, template = renderOptions.template, staticGenerate = renderOptions.staticGenerate, _renderOptions_enableUnsafeCtx = renderOptions.enableUnsafeCtx, enableUnsafeCtx = _renderOptions_enableUnsafeCtx === void 0 ? false : _renderOptions_enableUnsafeCtx, nonce = renderOptions.nonce;
+          urlPath = route.urlPath, bundle = route.bundle, entryName = route.entryName;
           bundleJS = path.join(distDir, bundle);
           loadableUri = path.join(distDir, LOADABLE_STATS_FILE);
           loadableStats = fs.existsSync(loadableUri) ? require(loadableUri) : "";
@@ -88,11 +91,22 @@ var render = function() {
               }
             ];
           } else {
+            contentStream = injectServerDataStream(content, ctx);
+            afterStreamingRenderContext = createAfterStreamingRenderContext(ctx, route);
+            contentStream = contentStream.pipe(afterRenderInjectableStream(function(chunk) {
+              var context2 = afterStreamingRenderContext(chunk);
+              return runner.afterStreamingRender(context2, {
+                onLast: function(param) {
+                  var _$chunk = param.chunk;
+                  return _$chunk;
+                }
+              });
+            }));
             return [
               2,
               {
                 content: "",
-                contentStream: injectServerDataStream(content, ctx),
+                contentStream,
                 contentType: mime.contentType("html")
               }
             ];

package/dist/esm/libs/render/ssrCache/manager.js

@@ -7,10 +7,10 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { Transform } from "stream";
 var CacheManager = /* @__PURE__ */ function() {
   "use strict";
-  function CacheManager2(containter) {
+  function CacheManager2(container) {
     _class_call_check(this, CacheManager2);
-    _define_property(this, "containter", void 0);
-    this.containter = containter;
+    _define_property(this, "container", void 0);
+    this.container = container;
   }
   _create_class(CacheManager2, [
     {
@@ -25,7 +25,7 @@ var CacheManager = /* @__PURE__ */ function() {
                 key = _this.computedKey(req, cacheControl);
                 return [
                   4,
-                  _this.containter.get(key)
+                  _this.container.get(key)
                 ];
               case 1:
                 value = _state.sent();
@@ -92,7 +92,7 @@ var CacheManager = /* @__PURE__ */ function() {
                 };
                 return [
                   4,
-                  _this.containter.set(key, JSON.stringify(cache), {
+                  _this.container.set(key, JSON.stringify(cache), {
                     ttl
                   })
                 ];
@@ -116,7 +116,7 @@ var CacheManager = /* @__PURE__ */ function() {
                     val: html,
                     cursor: current2
                   };
-                  _this.containter.set(key, JSON.stringify(cache2), {
+                  _this.container.set(key, JSON.stringify(cache2), {
                     ttl
                   });
                 });

package/dist/esm-node/libs/hook-api/afterRenderForStream.js

@@ -0,0 +1,10 @@
+import { Transform } from "stream";
+const afterRenderInjectableStream = (fn) => new Transform({
+  async write(chunk, _, callback) {
+    this.push(await fn(chunk.toString()));
+    callback();
+  }
+});
+export {
+  afterRenderInjectableStream
+};

package/dist/esm-node/libs/hook-api/index.js

@@ -25,6 +25,16 @@ const createAfterRenderContext = (context, route, content) => {
     template: new TemplateAPI(content)
   };
 };
+const createAfterStreamingRenderContext = (context, route) => {
+  const baseContext = base(context);
+  return (chunk) => {
+    return {
+      ...baseContext,
+      route,
+      chunk
+    };
+  };
+};
 const createMiddlewareContext = (context) => {
   const baseContext = base(context);
   baseContext.response.locals = context.res.locals || {};
@@ -42,5 +52,6 @@ export {
   base,
   createAfterMatchContext,
   createAfterRenderContext,
+  createAfterStreamingRenderContext,
   createMiddlewareContext
 };

package/dist/esm-node/libs/render/index.js

@@ -41,9 +41,7 @@ const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, s
       }
       const ssrRenderOptions = {
         distDir,
-        entryName: route.entryName,
-        urlPath: route.urlPath,
-        bundle: route.bundle,
+        route,
         template: content.toString(),
         staticGenerate,
         nonce

package/dist/esm-node/libs/render/ssr.js

@@ -1,11 +1,14 @@
 import path from "path";
 import { fs, mime, LOADABLE_STATS_FILE, ROUTE_MANIFEST_FILE, SERVER_RENDER_FUNCTION_NAME } from "@modern-js/utils";
+import { createAfterStreamingRenderContext } from "../hook-api";
+import { afterRenderInjectableStream } from "../hook-api/afterRenderForStream";
 import { createLogger, createMetrics } from "./measure";
 import { injectServerDataStream, injectServerData } from "./utils";
 import { ssrCache } from "./ssrCache";
 const render = async (ctx, renderOptions, runner) => {
   var _ctx_res;
-  const { urlPath, bundle, distDir, template, entryName, staticGenerate, enableUnsafeCtx = false, nonce } = renderOptions;
+  const { distDir, route, template, staticGenerate, enableUnsafeCtx = false, nonce } = renderOptions;
+  const { urlPath, bundle, entryName } = route;
   const bundleJS = path.join(distDir, bundle);
   const loadableUri = path.join(distDir, LOADABLE_STATS_FILE);
   const loadableStats = fs.existsSync(loadableUri) ? require(loadableUri) : "";
@@ -66,9 +69,17 @@ const render = async (ctx, renderOptions, runner) => {
       contentType: mime.contentType("html")
     };
   } else {
+    let contentStream = injectServerDataStream(content, ctx);
+    const afterStreamingRenderContext = createAfterStreamingRenderContext(ctx, route);
+    contentStream = contentStream.pipe(afterRenderInjectableStream((chunk) => {
+      const context2 = afterStreamingRenderContext(chunk);
+      return runner.afterStreamingRender(context2, {
+        onLast: ({ chunk: chunk2 }) => chunk2
+      });
+    }));
     return {
       content: "",
-      contentStream: injectServerDataStream(content, ctx),
+      contentStream,
       contentType: mime.contentType("html")
     };
   }

package/dist/esm-node/libs/render/ssrCache/manager.js

@@ -3,7 +3,7 @@ import { Transform } from "stream";
 class CacheManager {
   async getCacheResult(req, cacheControl, render, ssrContext) {
     const key = this.computedKey(req, cacheControl);
-    const value = await this.containter.get(key);
+    const value = await this.container.get(key);
     const { maxAge, staleWhileRevalidate } = cacheControl;
     const ttl = maxAge + staleWhileRevalidate;
     if (value) {
@@ -29,7 +29,7 @@ class CacheManager {
         val: renderResult,
         cursor: current
       };
-      await this.containter.set(key, JSON.stringify(cache), {
+      await this.container.set(key, JSON.stringify(cache), {
         ttl
       });
       return renderResult;
@@ -48,7 +48,7 @@ class CacheManager {
           val: html,
           cursor: current
         };
-        this.containter.set(key, JSON.stringify(cache), {
+        this.container.set(key, JSON.stringify(cache), {
           ttl
         });
       });
@@ -70,9 +70,9 @@ class CacheManager {
       return defaultKey;
     }
   }
-  constructor(containter) {
-    _define_property(this, "containter", void 0);
-    this.containter = containter;
+  constructor(container) {
+    _define_property(this, "container", void 0);
+    this.container = container;
   }
 }
 export {

package/dist/types/libs/hook-api/afterRenderForStream.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { Transform } from 'stream';
+import { MaybeAsync } from '@modern-js/plugin';
+export declare const afterRenderInjectableStream: (fn: (content: string) => MaybeAsync<string>) => Transform;

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

@@ -1,5 +1,6 @@
-import type { ModernServerContext, HookContext, AfterMatchContext, AfterRenderContext, MiddlewareContext, ServerRoute } from '@modern-js/types';
+import type { ModernServerContext, HookContext, AfterMatchContext, AfterRenderContext, MiddlewareContext, ServerRoute, AfterStreamingRenderContext } 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, route: Partial<ServerRoute>, content: string) => AfterRenderContext;
+export declare const createAfterStreamingRenderContext: (context: ModernServerContext, route: Partial<ServerRoute>) => (chunk: string) => AfterStreamingRenderContext;
 export declare const createMiddlewareContext: (context: ModernServerContext) => MiddlewareContext;

package/dist/types/libs/render/ssr.d.ts

@@ -1,12 +1,12 @@
 import type { ModernServerContext } from '@modern-js/types';
 import { RenderResult, ServerHookRunner } from '../../type';
-export declare const render: (ctx: ModernServerContext, renderOptions: {
+import type { ModernRoute } from '../route';
+export type SSRRenderOptions = {
     distDir: string;
-    bundle: string;
-    urlPath: string;
     template: string;
-    entryName: string;
+    route: ModernRoute;
     staticGenerate: boolean;
     enableUnsafeCtx?: boolean;
     nonce?: string;
-}, runner: ServerHookRunner) => Promise<RenderResult>;
+};
+export declare const render: (ctx: ModernServerContext, renderOptions: SSRRenderOptions, runner: ServerHookRunner) => Promise<RenderResult>;

package/dist/types/libs/render/ssrCache/manager.d.ts

@@ -6,8 +6,8 @@ import { Readable } from 'stream';
 import { CacheControl, Container } from '@modern-js/types';
 import { RenderFunction, SSRServerContext } from '../type';
 export declare class CacheManager {
-    private containter;
-    constructor(containter: Container<string, string>);
+    private container;
+    constructor(container: Container<string, string>);
     getCacheResult(req: IncomingMessage, cacheControl: CacheControl, render: RenderFunction, ssrContext: SSRServerContext): Promise<string | Readable>;
     private processCache;
     private computedKey;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.43.0",
+  "version": "2.44.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -73,10 +73,10 @@
     "node-html-parser": "^6.1.5",
     "path-to-regexp": "^6.2.0",
     "serve-static": "^1.14.1",
-    "@modern-js/server-core": "2.43.0",
-    "@modern-js/utils": "2.43.0",
-    "@modern-js/runtime-utils": "2.43.0",
-    "@modern-js/plugin": "2.43.0"
+    "@modern-js/plugin": "2.44.0",
+    "@modern-js/server-core": "2.44.0",
+    "@modern-js/utils": "2.44.0",
+    "@modern-js/runtime-utils": "2.44.0"
   },
   "devDependencies": {
     "@types/cookie": "0.5.1",
@@ -94,9 +94,9 @@
     "portfinder": "^1.0.28",
     "typescript": "^5",
     "ws": "^8.13.0",
-    "@modern-js/types": "2.43.0",
-    "@scripts/jest-config": "2.43.0",
-    "@scripts/build": "2.43.0"
+    "@modern-js/types": "2.44.0",
+    "@scripts/build": "2.44.0",
+    "@scripts/jest-config": "2.44.0"
   },
   "sideEffects": false,
   "publishConfig": {