@modern-js/plugin-ssg 2.69.4 → 3.0.0-alpha.0

package/dist/cjs/server/index.js

@@ -1,96 +1,141 @@
 "use strict";
-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 __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);
-var server_exports = {};
-__export(server_exports, {
-  createServer: () => createServer
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createServer: ()=>createServer
 });
-module.exports = __toCommonJS(server_exports);
-var import_child_process = __toESM(require("child_process"));
-var import_path = __toESM(require("path"));
-var import_utils = require("@modern-js/utils");
-var import_util = require("../libs/util");
-var import_consts = require("./consts");
-const createServer = (api, ssgRoutes, pageRoutes, apiRoutes, options, appDirectory) => new Promise((resolve, reject) => {
-  var _cp_stderr, _cp_stdout;
-  const entries = ssgRoutes.map((route) => route.entryName);
-  const backup = (0, import_util.openRouteSSR)(pageRoutes, entries);
-  const total = backup.concat(apiRoutes);
-  const cp = import_child_process.default.fork(import_path.default.join(__dirname, "process"), {
-    cwd: appDirectory,
-    silent: true
-  });
-  const appContext = api.useAppContext();
-  const plugins = appContext.serverPlugins;
-  cp.send(JSON.stringify({
-    options,
-    renderRoutes: ssgRoutes,
-    routes: total,
-    appContext: {
-      // Make sure that bff runs the product of the dist directory, because we dont register ts-node in the child process
-      apiDirectory: import_path.default.join(appContext.distDirectory, import_path.default.relative(appContext.appDirectory, appContext.apiDirectory)),
-      lambdaDirectory: import_path.default.join(appContext.distDirectory, import_path.default.relative(appContext.appDirectory, appContext.lambdaDirectory)),
-      appDirectory: appContext.appDirectory
-    },
-    plugins,
-    distDirectory: appContext.distDirectory
-  }));
-  const htmlChunks = [];
-  const htmlAry = [];
-  cp.on("message", (chunk) => {
-    if (chunk !== null) {
-      htmlChunks.push(chunk);
-    } else {
-      const html = htmlChunks.join("");
-      htmlAry.push(html);
-      htmlChunks.length = 0;
-    }
-    if (htmlAry.length === ssgRoutes.length) {
-      cp.send(import_consts.CLOSE_SIGN);
-      resolve(htmlAry);
+const external_node_http_namespaceObject = require("node:http");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const prod_server_namespaceObject = require("@modern-js/prod-server");
+const utils_namespaceObject = require("@modern-js/utils");
+const util_js_namespaceObject = require("../libs/util.js");
+function getLogger() {
+    const l = (0, utils_namespaceObject.createLogger)({
+        level: 'verbose'
+    });
+    return {
+        ...l,
+        error: (...args)=>{
+            console.error(...args);
+        }
+    };
+}
+const MAX_CONCURRENT_REQUESTS = 10;
+function createMockIncomingMessage(url, headers = {}) {
+    const urlObj = new URL(url);
+    const mockReq = new external_node_http_namespaceObject.IncomingMessage({});
+    mockReq.url = urlObj.pathname + urlObj.search;
+    mockReq.method = 'GET';
+    mockReq.headers = {
+        host: urlObj.host,
+        'user-agent': 'SSG-Renderer/1.0',
+        accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'accept-language': 'en-US,en;q=0.5',
+        'accept-encoding': 'gzip, deflate',
+        connection: 'keep-alive',
+        ...headers
+    };
+    mockReq.httpVersion = '1.1';
+    mockReq.httpVersionMajor = 1;
+    mockReq.httpVersionMinor = 1;
+    mockReq.complete = true;
+    mockReq.rawHeaders = [];
+    mockReq.socket = {};
+    mockReq.connection = mockReq.socket;
+    return mockReq;
+}
+function createMockServerResponse() {
+    const mockRes = new external_node_http_namespaceObject.ServerResponse({});
+    return mockRes;
+}
+const createServer = async (appContext, ssgRoutes, pageRoutes, apiRoutes, options)=>{
+    const entries = ssgRoutes.map((route)=>route.entryName);
+    const backup = (0, util_js_namespaceObject.openRouteSSR)(pageRoutes, entries);
+    const total = backup.concat(apiRoutes);
+    try {
+        const meta = (0, utils_namespaceObject.getMeta)(appContext.metaName);
+        const distDirectory = appContext.distDirectory;
+        const serverConfigPath = external_path_default().resolve(distDirectory, utils_namespaceObject.SERVER_DIR, `${meta}.server`);
+        const plugins = appContext.serverPlugins;
+        const serverOptions = {
+            pwd: distDirectory,
+            config: options,
+            appContext,
+            serverConfigPath,
+            routes: total,
+            plugins: await (0, prod_server_namespaceObject.loadServerPlugins)(plugins, appContext.appDirectory || distDirectory),
+            staticGenerate: true,
+            logger: getLogger()
+        };
+        const nodeServer = await (0, prod_server_namespaceObject.createProdServer)(serverOptions);
+        const requestHandler = nodeServer.getRequestHandler();
+        const chunkedRoutes = (0, util_js_namespaceObject.chunkArray)(ssgRoutes, MAX_CONCURRENT_REQUESTS);
+        const results = [];
+        for (const routes of chunkedRoutes){
+            const promises = routes.map(async (route)=>{
+                const url = `http://localhost${route.urlPath}`;
+                const request = new Request(url, {
+                    method: 'GET',
+                    headers: {
+                        host: 'localhost',
+                        'x-modern-ssg-render': 'true'
+                    }
+                });
+                const mockReq = createMockIncomingMessage(url);
+                const mockRes = createMockServerResponse();
+                const response = await requestHandler(request, {
+                    node: {
+                        req: mockReq,
+                        res: mockRes
+                    }
+                });
+                return await response.text();
+            });
+            const batch = await Promise.all(promises);
+            results.push(...batch);
+        }
+        return results;
+    } catch (e) {
+        utils_namespaceObject.logger.error(e instanceof Error ? e.stack : e.toString());
+        throw new Error('ssg render failed');
     }
-  });
-  (_cp_stderr = cp.stderr) === null || _cp_stderr === void 0 ? void 0 : _cp_stderr.on("data", (chunk) => {
-    const str = chunk.toString();
-    if (str.includes("Error")) {
-      import_utils.logger.error(str);
-      reject(new Error("ssg render failed"));
-      cp.kill("SIGKILL");
-    } else {
-      import_utils.logger.info(str.replace(/[^\S\n]+/g, " "));
-    }
-  });
-  (_cp_stdout = cp.stdout) === null || _cp_stdout === void 0 ? void 0 : _cp_stdout.on("data", (chunk) => {
-    const str = chunk.toString();
-    import_utils.logger.info(str.replace(/[^\S\n]+/g, " "));
-  });
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createServer
+};
+exports.createServer = __webpack_exports__.createServer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createServer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/server/prerender.js

@@ -1,71 +1,75 @@
 "use strict";
-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 __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);
-var prerender_exports = {};
-__export(prerender_exports, {
-  compile: () => compile
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    compile: ()=>compile
 });
-module.exports = __toCommonJS(prerender_exports);
-var import_events = __toESM(require("events"));
-var import_stream = require("stream");
-var import_node_mocks_http = __toESM(require("node-mocks-http"));
-const compile = (requestHandler) => (options, extend = {}) => new Promise((resolve, reject) => {
-  const req = import_node_mocks_http.default.createRequest({
-    ...options,
-    eventEmitter: import_stream.Readable
-  });
-  const res = import_node_mocks_http.default.createResponse({
-    eventEmitter: import_events.default
-  });
-  Object.assign(req, extend);
-  const proxyRes = new Proxy(res, {
-    get(obj, prop) {
-      if (typeof prop === "symbol" && !obj[prop]) {
-        return null;
-      }
-      return obj[prop];
-    }
-  });
-  res.on("finish", () => {
-    if (res.statusCode !== 200) {
-      reject(new Error(res.statusMessage));
-    } else {
-      resolve(res._getData());
-    }
-  });
-  res.on("error", (e) => reject(e));
-  try {
-    requestHandler(req, proxyRes);
-  } catch (e) {
-    reject(e);
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  compile
+const external_events_namespaceObject = require("events");
+var external_events_default = /*#__PURE__*/ __webpack_require__.n(external_events_namespaceObject);
+const external_stream_namespaceObject = require("stream");
+const external_node_mocks_http_namespaceObject = require("node-mocks-http");
+var external_node_mocks_http_default = /*#__PURE__*/ __webpack_require__.n(external_node_mocks_http_namespaceObject);
+const compile = (requestHandler)=>(options, extend = {})=>new Promise((resolve, reject)=>{
+            const req = external_node_mocks_http_default().createRequest({
+                ...options,
+                eventEmitter: external_stream_namespaceObject.Readable
+            });
+            const res = external_node_mocks_http_default().createResponse({
+                eventEmitter: external_events_default()
+            });
+            Object.assign(req, extend);
+            const proxyRes = new Proxy(res, {
+                get (obj, prop) {
+                    if ('symbol' == typeof prop && !obj[prop]) return null;
+                    return obj[prop];
+                }
+            });
+            res.on('finish', ()=>{
+                if (200 !== res.statusCode) reject(new Error(res.statusMessage));
+                else resolve(res._getData());
+            });
+            res.on('error', (e)=>reject(e));
+            try {
+                requestHandler(req, proxyRes);
+            } catch (e) {
+                reject(e);
+            }
+        });
+exports.compile = __webpack_exports__.compile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "compile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/types.js

@@ -1,16 +1,18 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 types_exports = {};
-module.exports = __toCommonJS(types_exports);
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/index.mjs

@@ -0,0 +1,89 @@
+import path from "path";
+import { filterRoutesForServer, logger } from "@modern-js/utils";
+import { makeRoute } from "./libs/make";
+import { writeHtmlFile } from "./libs/output";
+import { replaceRoute } from "./libs/replace";
+import { flattenRoutes, formatOutput, isDynamicUrl, readJSONSpec, standardOptions, writeJSONSpec } from "./libs/util";
+import { createServer } from "./server";
+const ssgPlugin = ()=>({
+        name: '@modern-js/plugin-ssg',
+        pre: [
+            '@modern-js/plugin-bff'
+        ],
+        setup: (api)=>{
+            const agreedRouteMap = {};
+            api.modifyFileSystemRoutes(async ({ entrypoint, routes })=>{
+                const { entryName } = entrypoint;
+                const flattedRoutes = flattenRoutes(filterRoutesForServer(routes));
+                agreedRouteMap[entryName] = flattedRoutes;
+                return {
+                    entrypoint,
+                    routes
+                };
+            });
+            api.onAfterBuild(async ()=>{
+                const resolvedConfig = api.getNormalizedConfig();
+                const appContext = api.getAppContext();
+                const { appDirectory, entrypoints } = appContext;
+                const { output, server } = resolvedConfig;
+                const { ssg, ssgByEntries, distPath: { root: outputPath } = {} } = output;
+                const ssgOptions = (Array.isArray(ssg) ? ssg.pop() : ssg) ?? true;
+                const buildDir = path.join(appDirectory, outputPath);
+                const routes = readJSONSpec(buildDir);
+                const pageRoutes = routes.filter((route)=>route.isSPA);
+                const apiRoutes = routes.filter((route)=>!route.isSPA);
+                if (0 === pageRoutes.length) return;
+                const intermediateOptions = standardOptions(ssgOptions, entrypoints, pageRoutes, server, ssgByEntries);
+                if (!intermediateOptions) return;
+                const ssgRoutes = [];
+                pageRoutes.forEach((pageRoute)=>{
+                    const { entryName, entryPath } = pageRoute;
+                    const agreedRoutes = agreedRouteMap[entryName];
+                    let entryOptions = intermediateOptions[entryName] || intermediateOptions[pageRoute.urlPath];
+                    if (agreedRoutes) {
+                        if (!entryOptions) return;
+                        if (true === entryOptions) entryOptions = {
+                            routes: [],
+                            headers: {}
+                        };
+                        const { routes: userRoutes = [], headers } = entryOptions || {};
+                        if (userRoutes.length > 0) userRoutes.forEach((route)=>{
+                            ssgRoutes.push(makeRoute(pageRoute, route, headers));
+                        });
+                        else agreedRoutes.forEach((route)=>{
+                            if (!isDynamicUrl(route.path)) ssgRoutes.push(makeRoute(pageRoute, route.path, headers));
+                        });
+                    } else {
+                        if (!entryOptions) return;
+                        if (true === entryOptions) ssgRoutes.push({
+                            ...pageRoute,
+                            output: entryPath
+                        });
+                        else if (entryOptions.routes && entryOptions.routes.length > 0) {
+                            const { routes: enrtyRoutes, headers } = entryOptions;
+                            enrtyRoutes.forEach((route)=>{
+                                ssgRoutes.push(makeRoute(pageRoute, route, headers));
+                            });
+                        }
+                    }
+                });
+                if (0 === ssgRoutes.length) return;
+                ssgRoutes.forEach((ssgRoute)=>{
+                    if (ssgRoute.isSSR) {
+                        const isOriginRoute = pageRoutes.some((pageRoute)=>pageRoute.urlPath === ssgRoute.urlPath && pageRoute.entryName === ssgRoute.entryName);
+                        if (isOriginRoute) throw new Error(`ssg can not using with ssr，url - ${ssgRoute.urlPath}, entry - ${ssgRoute.entryName} `);
+                        logger.warn(`new ssg route ${ssgRoute.urlPath} is using ssr now，maybe from parent route ${ssgRoute.entryName}，close ssr`);
+                    }
+                    ssgRoute.isSSR = false;
+                    ssgRoute.output = formatOutput(ssgRoute.output);
+                });
+                const htmlAry = await createServer(appContext, ssgRoutes, pageRoutes, apiRoutes, resolvedConfig);
+                writeHtmlFile(htmlAry, ssgRoutes, buildDir);
+                replaceRoute(ssgRoutes, pageRoutes);
+                writeJSONSpec(buildDir, pageRoutes.concat(apiRoutes));
+                logger.info('ssg Compiled successfully');
+            });
+        }
+    });
+const src = ssgPlugin;
+export { src as default, ssgPlugin };

package/dist/esm/libs/make.mjs

@@ -0,0 +1,31 @@
+import path from "path";
+import normalize_path from "normalize-path";
+function makeRender(ssgRoutes, render, port) {
+    return ssgRoutes.map((ssgRoute)=>render({
+            url: ssgRoute.urlPath,
+            headers: {
+                host: `localhost:${port}`,
+                ...ssgRoute.headers
+            },
+            connection: {}
+        }));
+}
+function makeRoute(baseRoute, route, headers = {}) {
+    const { urlPath, entryPath } = baseRoute;
+    if ('string' == typeof route) return {
+        ...baseRoute,
+        urlPath: normalize_path(`${urlPath}${route}`) || '/',
+        headers,
+        output: path.join(entryPath, `..${'/' === route ? '' : route}`)
+    };
+    return {
+        ...baseRoute,
+        urlPath: normalize_path(`${urlPath}${route.url}`) || '/',
+        headers: {
+            ...headers,
+            ...route.headers
+        },
+        output: route.output ? path.normalize(route.output) : path.join(entryPath, `..${'/' === route.url ? '' : route.url}`)
+    };
+}
+export { makeRender, makeRoute };

package/dist/esm/libs/output.mjs

@@ -0,0 +1,11 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+function writeHtmlFile(htmlAry, ssgRoutes, baseDir) {
+    htmlAry.forEach((html, index)=>{
+        const ssgRoute = ssgRoutes[index];
+        const filepath = path.join(baseDir, ssgRoute.output);
+        if (!fs.existsSync(path.dirname(filepath))) fs.ensureDirSync(path.dirname(filepath));
+        fs.writeFileSync(filepath, html);
+    });
+}
+export { writeHtmlFile };

package/dist/esm/libs/replace.mjs

@@ -0,0 +1,28 @@
+import normalize_path from "normalize-path";
+function exist(route, pageRoutes) {
+    return pageRoutes.slice().findIndex((pageRoute)=>{
+        const urlEqual = normalize_path(pageRoute.urlPath) === normalize_path(route.urlPath);
+        const entryEqual = pageRoute.entryName === route.entryName;
+        if (urlEqual && entryEqual) return true;
+        return false;
+    });
+}
+function replaceRoute(ssgRoutes, pageRoutes) {
+    const cleanSsgRoutes = ssgRoutes.map((ssgRoute)=>{
+        const { output, headers, ...cleanSsgRoute } = ssgRoute;
+        return Object.assign(cleanSsgRoute, output ? {
+            entryPath: output
+        } : {});
+    });
+    const freshRoutes = [];
+    cleanSsgRoutes.forEach((ssgRoute)=>{
+        const index = exist(ssgRoute, pageRoutes);
+        if (index < 0) freshRoutes.push({
+            ...ssgRoute
+        });
+        else pageRoutes[index].entryPath = ssgRoute.entryPath;
+    });
+    pageRoutes.push(...freshRoutes);
+    return pageRoutes;
+}
+export { exist, replaceRoute };