@modern-js/plugin-ssg 0.0.0-next-1e7c2c5a6 → 0.0.0-next-0bf5ec13d2

package/CHANGELOG.md

@@ -1,10 +1,10 @@
 # @modern-js/plugin-ssg
 
-## 0.0.0-next-1e7c2c5a6
+## 0.0.0-next-0bf5ec13d2
 
 ### Patch Changes
 
-- @modern-js/utils@0.0.0-next-1e7c2c5a6
+- @modern-js/utils@0.0.0-next-0bf5ec13d2
 
 ## 2.7.0
 

package/dist/js/modern/index.js

@@ -0,0 +1,189 @@
+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
+};

package/dist/js/modern/libs/make.js

@@ -0,0 +1,50 @@
+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 normalize from "normalize-path";
+function makeRender(ssgRoutes, render, port) {
+  return ssgRoutes.map(
+    (ssgRoute) => render({
+      url: ssgRoute.urlPath,
+      headers: __spreadValues({ host: `localhost:${port}` }, ssgRoute.headers),
+      connection: {}
+    })
+  );
+}
+function makeRoute(baseRoute, route, headers = {}) {
+  const { urlPath, entryPath } = baseRoute;
+  if (typeof route === "string") {
+    return __spreadProps(__spreadValues({}, baseRoute), {
+      urlPath: normalize(`${urlPath}${route}`) || "/",
+      headers,
+      output: path.join(entryPath, `..${route === "/" ? "" : route}`)
+    });
+  } else {
+    return __spreadProps(__spreadValues({}, baseRoute), {
+      urlPath: normalize(`${urlPath}${route.url}`) || "/",
+      headers: __spreadValues(__spreadValues({}, headers), route.headers),
+      output: route.output ? path.normalize(route.output) : path.join(entryPath, `..${route.url === "/" ? "" : route.url}`)
+    });
+  }
+}
+export {
+  makeRender,
+  makeRoute
+};

package/dist/js/modern/libs/output.js

@@ -0,0 +1,15 @@
+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/js/modern/libs/replace.js

@@ -0,0 +1,63 @@
+var __defProp = Object.defineProperty;
+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 __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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 _a = ssgRoute, { output, headers } = _a, cleanSsgRoute = __objRest(_a, ["output", "headers"]);
+    return Object.assign(
+      cleanSsgRoute,
+      output ? { entryPath: output } : {}
+    );
+  });
+  const freshRoutes = [];
+  cleanSsgRoutes.forEach((ssgRoute) => {
+    const index = exist(ssgRoute, pageRoutes);
+    if (index < 0) {
+      freshRoutes.push(__spreadValues({}, ssgRoute));
+    } else {
+      pageRoutes[index].entryPath = ssgRoute.entryPath;
+    }
+  });
+  pageRoutes.push(...freshRoutes);
+  return pageRoutes;
+}
+export {
+  exist,
+  replaceRoute
+};

package/dist/js/modern/libs/util.js

@@ -0,0 +1,171 @@
+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,
+  fs,
+  isSingleEntry,
+  SERVER_BUNDLE_DIRECTORY
+} from "@modern-js/utils";
+function formatOutput(filename) {
+  const outputPath = path.extname(filename) ? filename : `${filename}/index.html`;
+  return outputPath;
+}
+function formatPath(str) {
+  let addr = str;
+  if (!addr || typeof addr !== "string") {
+    return addr;
+  }
+  if (addr.startsWith(".")) {
+    addr = addr.slice(1);
+  }
+  if (!addr.startsWith("/")) {
+    addr = `/${addr}`;
+  }
+  if (addr.endsWith("/") && addr !== "/") {
+    addr = addr.slice(0, addr.length - 1);
+  }
+  return addr;
+}
+function isDynamicUrl(url) {
+  return url.includes(":");
+}
+function getUrlPrefix(route, baseUrl) {
+  let base = "";
+  if (Array.isArray(baseUrl)) {
+    const filters = baseUrl.filter((url) => route.urlPath.includes(url));
+    if (filters.length > 1) {
+      const matched = filters.sort((a, b) => a.length - b.length)[0];
+      if (!matched) {
+        throw new Error("");
+      }
+      base = matched;
+    }
+  } else {
+    base = baseUrl;
+  }
+  base = base === "/" ? "" : base;
+  const entryName = route.entryName === "main" ? "" : route.entryName;
+  const prefix = `${base}/${entryName}`;
+  return prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+}
+function getOutput(route, base, agreed) {
+  const { output } = route;
+  if (output) {
+    return output;
+  }
+  if (agreed) {
+    const urlWithoutBase = route.urlPath.replace(base, "");
+    return urlWithoutBase.startsWith("/") ? urlWithoutBase.slice(1) : urlWithoutBase;
+  }
+  throw new Error(
+    `routing must provide output when calling createPage(), check ${route.urlPath}`
+  );
+}
+const readJSONSpec = (dir) => {
+  const routeJSONPath = path.join(dir, ROUTE_SPEC_FILE);
+  const routeJSON = require(routeJSONPath);
+  const { routes } = routeJSON;
+  return routes;
+};
+const writeJSONSpec = (dir, routes) => {
+  const routeJSONPath = path.join(dir, ROUTE_SPEC_FILE);
+  fs.writeJSONSync(routeJSONPath, { routes }, { spaces: 2 });
+};
+const replaceWithAlias = (base, filePath, alias) => path.posix.join(alias, path.posix.relative(base, filePath));
+const standardOptions = (ssgOptions, entrypoints, routes, server) => {
+  if (ssgOptions === false) {
+    return false;
+  }
+  if (ssgOptions === true) {
+    return entrypoints.reduce((opt, entry) => {
+      opt[entry.entryName] = ssgOptions;
+      return opt;
+    }, {});
+  } else if (typeof ssgOptions === "object") {
+    const isSingle = isSingleEntry(entrypoints);
+    if (isSingle && typeof ssgOptions.main === "undefined") {
+      return { main: ssgOptions };
+    } else {
+      return ssgOptions;
+    }
+  } else if (typeof ssgOptions === "function") {
+    const intermediateOptions = {};
+    for (const entrypoint of entrypoints) {
+      const { entryName } = entrypoint;
+      if (Array.isArray(server == null ? void 0 : server.baseUrl)) {
+        for (const url of server.baseUrl) {
+          const matchUrl = entryName === "main" ? url : `${url}/${entryName}`;
+          const route = routes.find((route2) => route2.urlPath === matchUrl);
+          intermediateOptions[route == null ? void 0 : route.urlPath] = ssgOptions(
+            entryName,
+            { baseUrl: url }
+          );
+        }
+      } else {
+        intermediateOptions[entryName] = ssgOptions(entryName, {
+          baseUrl: server == null ? void 0 : server.baseUrl
+        });
+      }
+    }
+    return intermediateOptions;
+  }
+  return false;
+};
+const openRouteSSR = (routes, entries = []) => routes.map((ssgRoute) => __spreadProps(__spreadValues({}, ssgRoute), {
+  isSSR: entries.includes(ssgRoute.entryName),
+  bundle: `${SERVER_BUNDLE_DIRECTORY}/${ssgRoute.entryName}.js`
+}));
+const flattenRoutes = (routes) => {
+  const parents = [];
+  const newRoutes = [];
+  const traverseRoute = (route) => {
+    const parent = parents[parents.length - 1];
+    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), {
+        path: path2
+      }));
+    }
+    if (route.children) {
+      parents.push(__spreadProps(__spreadValues({}, route), {
+        path: path2
+      }));
+      route.children.forEach(traverseRoute);
+      parents.pop();
+    }
+  };
+  routes.forEach(traverseRoute);
+  return newRoutes;
+};
+export {
+  flattenRoutes,
+  formatOutput,
+  formatPath,
+  getOutput,
+  getUrlPrefix,
+  isDynamicUrl,
+  openRouteSSR,
+  readJSONSpec,
+  replaceWithAlias,
+  standardOptions,
+  writeJSONSpec
+};

package/dist/js/modern/server/consts.js

@@ -0,0 +1,4 @@
+const CLOSE_SIGN = "modern_close_server";
+export {
+  CLOSE_SIGN
+};

package/dist/js/modern/server/index.js

@@ -0,0 +1,63 @@
+import childProcess from "child_process";
+import path from "path";
+import { logger } from "@modern-js/utils";
+import { openRouteSSR } from "../libs/util";
+import { CLOSE_SIGN } from "./consts";
+const createServer = (api, ssgRoutes, pageRoutes, apiRoutes, options, appDirectory) => new Promise((resolve, reject) => {
+  const entries = ssgRoutes.map((route) => route.entryName);
+  const backup = openRouteSSR(pageRoutes, entries);
+  const total = backup.concat(apiRoutes);
+  const cp = childProcess.fork(path.join(__dirname, "process"), {
+    cwd: appDirectory,
+    silent: true
+  });
+  const appContext = api.useAppContext();
+  const plugins = appContext.serverInternalPlugins;
+  cp.send(
+    JSON.stringify({
+      options,
+      renderRoutes: ssgRoutes,
+      routes: total,
+      appDirectory,
+      plugins
+    })
+  );
+  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(CLOSE_SIGN);
+      resolve(htmlAry);
+    }
+  });
+  cp.stderr.on("data", (chunk) => {
+    const str = chunk.toString();
+    if (str.includes("Error")) {
+      logger.error(str);
+      reject(new Error("ssg render failed"));
+      cp.kill("SIGKILL");
+    } else {
+      logger.info(str.replace(/[^\S\n]+/g, " "));
+    }
+  });
+  cp.stdout.on("data", (chunk) => {
+    const str = chunk.toString();
+    if (str.includes("Error")) {
+      logger.error(str);
+      reject(new Error("ssg render failed"));
+      cp.kill("SIGKILL");
+    } else {
+      logger.info(str.replace(/[^\S\n]+/g, " "));
+    }
+  });
+});
+export {
+  createServer
+};

package/dist/js/modern/server/prerender.js

@@ -0,0 +1,53 @@
+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 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(__spreadProps(__spreadValues({}, 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
+};