@modern-js/plugin-ssg 2.4.0 → 2.5.0

package/dist/esm-node/index.js

@@ -0,0 +1,148 @@
+import path from "path";
+import { logger, PLUGIN_SCHEMAS } from "@modern-js/utils";
+import { generatePath } from "react-router-dom";
+import {
+  flattenRoutes,
+  formatOutput,
+  isDynamicUrl,
+  readJSONSpec,
+  standardOptions,
+  writeJSONSpec
+} from "./libs/util";
+import { createServer } from "./server";
+import { writeHtmlFile } from "./libs/output";
+import { replaceRoute } from "./libs/replace";
+import { makeRoute } from "./libs/make";
+var src_default = () => ({
+  name: "@modern-js/plugin-ssg",
+  pre: ["@modern-js/plugin-server", "@modern-js/plugin-bff"],
+  setup: (api) => {
+    const agreedRouteMap = {};
+    return {
+      validateSchema() {
+        return PLUGIN_SCHEMAS["@modern-js/plugin-ssg"];
+      },
+      modifyFileSystemRoutes({ entrypoint, routes }) {
+        const { entryName } = entrypoint;
+        const flattedRoutes = flattenRoutes(routes);
+        agreedRouteMap[entryName] = flattedRoutes;
+        return { entrypoint, routes };
+      },
+      async afterBuild() {
+        const resolvedConfig = api.useResolvedConfigContext();
+        const appContext = api.useAppContext();
+        const { appDirectory, entrypoints } = appContext;
+        const { output, server } = resolvedConfig;
+        const { ssg, 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.isApi);
+        const apiRoutes = routes.filter((route) => route.isApi);
+        if (pageRoutes.length === 0) {
+          return;
+        }
+        const intermediateOptions = standardOptions(
+          ssgOptions,
+          entrypoints,
+          pageRoutes,
+          server
+        );
+        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 (entryOptions === true) {
+              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));
+              });
+            }
+          } else {
+            if (!entryOptions) {
+              return;
+            }
+            if (entryOptions === true) {
+              entryOptions = { preventDefault: [], routes: [], headers: {} };
+            }
+            const {
+              preventDefault = [],
+              routes: userRoutes = [],
+              headers
+            } = entryOptions;
+            if (userRoutes.length > 0) {
+              userRoutes.forEach((route) => {
+                if (typeof route === "string") {
+                  ssgRoutes.push(makeRoute(pageRoute, route, headers));
+                } else if (Array.isArray(route.params)) {
+                  route.params.forEach((param) => {
+                    ssgRoutes.push(
+                      makeRoute(
+                        pageRoute,
+                        { ...route, url: generatePath(route.url, param) },
+                        headers
+                      )
+                    );
+                  });
+                } else {
+                  ssgRoutes.push(makeRoute(pageRoute, route, headers));
+                }
+              });
+            } else {
+              agreedRoutes.filter((route) => !preventDefault.includes(route.path)).forEach((route) => {
+                if (!isDynamicUrl(route.path)) {
+                  ssgRoutes.push(makeRoute(pageRoute, route.path, headers));
+                }
+              });
+            }
+          }
+        });
+        if (ssgRoutes.length === 0) {
+          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(
+          api,
+          ssgRoutes,
+          pageRoutes,
+          apiRoutes,
+          resolvedConfig,
+          appDirectory
+        );
+        writeHtmlFile(htmlAry, ssgRoutes, buildDir);
+        replaceRoute(ssgRoutes, pageRoutes);
+        writeJSONSpec(buildDir, pageRoutes.concat(apiRoutes));
+        logger.info("ssg Compiled successfully");
+      }
+    };
+  }
+});
+export {
+  src_default as default
+};

package/dist/esm-node/libs/make.js

@@ -0,0 +1,33 @@
+import path from "path";
+import normalize 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 (typeof route === "string") {
+    return {
+      ...baseRoute,
+      urlPath: normalize(`${urlPath}${route}`) || "/",
+      headers,
+      output: path.join(entryPath, `..${route === "/" ? "" : route}`)
+    };
+  } else {
+    return {
+      ...baseRoute,
+      urlPath: normalize(`${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-node/libs/replace.js

@@ -0,0 +1,35 @@
+import normalize from "normalize-path";
+function exist(route, pageRoutes) {
+  return pageRoutes.slice().findIndex((pageRoute) => {
+    const urlEqual = normalize(pageRoute.urlPath) === normalize(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
+};

package/dist/{js/modern → esm-node}/libs/util.js

@@ -1,22 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import path from "path";
 import {
   ROUTE_SPEC_FILE,
@@ -129,7 +110,8 @@ const standardOptions = (ssgOptions, entrypoints, routes, server) => {
   }
   return false;
 };
-const openRouteSSR = (routes, entries = []) => routes.map((ssgRoute) => __spreadProps(__spreadValues({}, ssgRoute), {
+const openRouteSSR = (routes, entries = []) => routes.map((ssgRoute) => ({
+  ...ssgRoute,
   isSSR: entries.includes(ssgRoute.entryName),
   bundle: `${SERVER_BUNDLE_DIRECTORY}/${ssgRoute.entryName}.js`
 }));
@@ -141,14 +123,16 @@ const flattenRoutes = (routes) => {
     let path2 = parent ? `${parent.path}/${route.path || ""}`.replace(/\/+/g, "/") : route.path || "";
     path2 = path2.replace(/\/$/, "");
     if (route._component && (path2 !== "/" || path2 === "/" && !parent)) {
-      newRoutes.push(__spreadProps(__spreadValues({}, route), {
+      newRoutes.push({
+        ...route,
         path: path2
-      }));
+      });
     }
     if (route.children) {
-      parents.push(__spreadProps(__spreadValues({}, route), {
+      parents.push({
+        ...route,
         path: path2
-      }));
+      });
       route.children.forEach(traverseRoute);
       parents.pop();
     }

package/dist/esm-node/server/prerender.js

@@ -0,0 +1,35 @@
+import EventEmitter from "events";
+import { Readable } from "stream";
+import httpMocks from "node-mocks-http";
+const compile = (requestHandler) => (options, extend = {}) => new Promise((resolve, reject) => {
+  const req = httpMocks.createRequest({
+    ...options,
+    eventEmitter: Readable
+  });
+  const res = httpMocks.createResponse({ eventEmitter: EventEmitter });
+  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);
+  }
+});
+export {
+  compile
+};

package/dist/esm-node/server/process.js

@@ -0,0 +1,55 @@
+import server from "@modern-js/prod-server";
+import portfinder from "portfinder";
+import { makeRender } from "../libs/make";
+import { compile as createRender } from "./prerender";
+import { CLOSE_SIGN } from "./consts";
+process.on("message", async (chunk) => {
+  if (chunk === CLOSE_SIGN) {
+    process.exit();
+  }
+  const context = JSON.parse(chunk);
+  const {
+    routes,
+    renderRoutes,
+    options,
+    appDirectory,
+    plugins
+  } = context;
+  let modernServer = null;
+  try {
+    const { server: serverOptions } = options;
+    const defaultPort = Number(process.env.PORT) || serverOptions.port;
+    portfinder.basePort = defaultPort;
+    const port = await portfinder.getPortPromise();
+    modernServer = await server({
+      pwd: appDirectory,
+      config: options,
+      routes,
+      staticGenerate: true,
+      internalPlugins: plugins
+    });
+    modernServer.listen(port, async (err) => {
+      if (err) {
+        throw err;
+      }
+      if (!modernServer) {
+        return;
+      }
+      const render = createRender(modernServer.getRequestHandler());
+      const renderPromiseAry = makeRender(
+        renderRoutes,
+        render,
+        port
+      );
+      const htmlAry = await Promise.all(renderPromiseAry);
+      htmlAry.forEach((html) => {
+        process.send(html);
+        process.send(null);
+      });
+      modernServer.close();
+    });
+  } catch (e) {
+    modernServer == null ? void 0 : modernServer.close();
+    throw e;
+  }
+});

package/dist/types/libs/util.d.ts

@@ -18,6 +18,7 @@ export declare const openRouteSSR: (routes: ModernRoute[], entries?: string[]) =
   entryPath: string;
   isSPA?: boolean | undefined;
   isApi?: boolean | undefined;
+  worker?: string | undefined;
   responseHeaders?: Record<string, unknown> | undefined;
 }[];
 export declare const flattenRoutes: (routes: AgreedRoute[]) => AgreedRoute[];

package/package.json

@@ -11,12 +11,11 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.4.0",
+  "version": "2.5.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
-  "main": "./dist/js/node/index.js",
-  "module": "./dist/js/treeshaking/index.js",
-  "jsnext:modern": "./dist/js/modern/index.js",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
   "typesVersions": {
     "*": {
       ".": [
@@ -31,26 +30,26 @@
     ".": {
       "node": {
         "jsnext:source": "./src/index.ts",
-        "import": "./dist/js/modern/index.js",
-        "require": "./dist/js/node/index.js"
+        "import": "./dist/esm-node/index.js",
+        "require": "./dist/cjs/index.js"
       },
-      "default": "./dist/js/treeshaking/index.js"
+      "default": "./dist/esm/index.js"
     },
     "./cli": {
       "jsnext:source": "./src/index.ts",
       "node": {
-        "import": "./dist/js/modern/index.js",
-        "require": "./dist/js/node/index.js"
+        "import": "./dist/esm-node/index.js",
+        "require": "./dist/cjs/index.js"
       },
-      "default": "./dist/js/treeshaking/index.js"
+      "default": "./dist/esm/index.js"
     },
     "./types": {
       "node": {
-        "import": "./dist/js/modern/types.js",
-        "require": "./dist/js/node/types.js",
+        "import": "./dist/esm-node/types.js",
+        "require": "./dist/cjs/types.js",
         "types": "./dist/types/types.d.ts"
       },
-      "default": "./dist/js/treeshaking/types.js"
+      "default": "./dist/esm/types.js"
     }
   },
   "dependencies": {
@@ -58,7 +57,7 @@
     "node-mocks-http": "^1.10.1",
     "normalize-path": "^3.0.0",
     "portfinder": "^1.0.28",
-    "@modern-js/utils": "2.4.0"
+    "@modern-js/utils": "2.5.0"
   },
   "peerDependencies": {
     "react-router-dom": ">=5.1.2"
@@ -75,11 +74,11 @@
     "react": "^18",
     "react-router-dom": "^6.6.0",
     "typescript": "^4",
-    "@modern-js/app-tools": "2.4.0",
-    "@modern-js/prod-server": "2.4.0",
-    "@modern-js/types": "2.4.0",
-    "@scripts/build": "2.4.0",
-    "@scripts/jest-config": "2.4.0"
+    "@modern-js/app-tools": "2.5.0",
+    "@modern-js/prod-server": "2.5.0",
+    "@modern-js/types": "2.5.0",
+    "@scripts/build": "2.5.0",
+    "@scripts/jest-config": "2.5.0"
   },
   "sideEffects": false,
   "publishConfig": {

package/dist/js/modern/index.js

@@ -1,189 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-import path from "path";
-import { logger, PLUGIN_SCHEMAS } from "@modern-js/utils";
-import { generatePath } from "react-router-dom";
-import {
-  flattenRoutes,
-  formatOutput,
-  isDynamicUrl,
-  readJSONSpec,
-  standardOptions,
-  writeJSONSpec
-} from "./libs/util";
-import { createServer } from "./server";
-import { writeHtmlFile } from "./libs/output";
-import { replaceRoute } from "./libs/replace";
-import { makeRoute } from "./libs/make";
-var src_default = () => ({
-  name: "@modern-js/plugin-ssg",
-  pre: ["@modern-js/plugin-server", "@modern-js/plugin-bff"],
-  setup: (api) => {
-    const agreedRouteMap = {};
-    return {
-      validateSchema() {
-        return PLUGIN_SCHEMAS["@modern-js/plugin-ssg"];
-      },
-      modifyFileSystemRoutes({ entrypoint, routes }) {
-        const { entryName } = entrypoint;
-        const flattedRoutes = flattenRoutes(routes);
-        agreedRouteMap[entryName] = flattedRoutes;
-        return { entrypoint, routes };
-      },
-      afterBuild() {
-        return __async(this, null, function* () {
-          const resolvedConfig = api.useResolvedConfigContext();
-          const appContext = api.useAppContext();
-          const { appDirectory, entrypoints } = appContext;
-          const { output, server } = resolvedConfig;
-          const { ssg, 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.isApi);
-          const apiRoutes = routes.filter((route) => route.isApi);
-          if (pageRoutes.length === 0) {
-            return;
-          }
-          const intermediateOptions = standardOptions(
-            ssgOptions,
-            entrypoints,
-            pageRoutes,
-            server
-          );
-          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 (entryOptions === true) {
-                ssgRoutes.push(__spreadProps(__spreadValues({}, 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));
-                });
-              }
-            } else {
-              if (!entryOptions) {
-                return;
-              }
-              if (entryOptions === true) {
-                entryOptions = { preventDefault: [], routes: [], headers: {} };
-              }
-              const {
-                preventDefault = [],
-                routes: userRoutes = [],
-                headers
-              } = entryOptions;
-              if (userRoutes.length > 0) {
-                userRoutes.forEach((route) => {
-                  if (typeof route === "string") {
-                    ssgRoutes.push(makeRoute(pageRoute, route, headers));
-                  } else if (Array.isArray(route.params)) {
-                    route.params.forEach((param) => {
-                      ssgRoutes.push(
-                        makeRoute(
-                          pageRoute,
-                          __spreadProps(__spreadValues({}, route), { url: generatePath(route.url, param) }),
-                          headers
-                        )
-                      );
-                    });
-                  } else {
-                    ssgRoutes.push(makeRoute(pageRoute, route, headers));
-                  }
-                });
-              } else {
-                agreedRoutes.filter((route) => !preventDefault.includes(route.path)).forEach((route) => {
-                  if (!isDynamicUrl(route.path)) {
-                    ssgRoutes.push(makeRoute(pageRoute, route.path, headers));
-                  }
-                });
-              }
-            }
-          });
-          if (ssgRoutes.length === 0) {
-            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 = yield createServer(
-            api,
-            ssgRoutes,
-            pageRoutes,
-            apiRoutes,
-            resolvedConfig,
-            appDirectory
-          );
-          writeHtmlFile(htmlAry, ssgRoutes, buildDir);
-          replaceRoute(ssgRoutes, pageRoutes);
-          writeJSONSpec(buildDir, pageRoutes.concat(apiRoutes));
-          logger.info("ssg Compiled successfully");
-        });
-      }
-    };
-  }
-});
-export {
-  src_default as default
-};