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

package/dist/esm-node/index.js

@@ -1,128 +0,0 @@
-import path from "path";
-import { filterRoutesForServer, logger } from "@modern-js/utils";
-import { generatePath } from "react-router-dom";
-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-server",
-    "@modern-js/plugin-bff"
-  ],
-  setup: (api) => {
-    const agreedRouteMap = {};
-    return {
-      modifyFileSystemRoutes({ entrypoint, routes }) {
-        const { entryName } = entrypoint;
-        const flattedRoutes = flattenRoutes(filterRoutesForServer(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.isSPA);
-        const apiRoutes = routes.filter((route) => !route.isSPA);
-        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");
-      }
-    };
-  }
-});
-var src_default = ssgPlugin;
-export {
-  src_default as default,
-  ssgPlugin
-};

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

@@ -1,37 +0,0 @@
-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/output.js

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

@@ -1,36 +0,0 @@
-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/esm-node/libs/util.js

@@ -1,161 +0,0 @@
-import path from "path";
-import { fs, ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, isSingleEntry } 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 || server === void 0 ? 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 || route === void 0 ? void 0 : route.urlPath] = ssgOptions(entryName, {
-            baseUrl: url
-          });
-        }
-      } else {
-        intermediateOptions[entryName] = ssgOptions(entryName, {
-          baseUrl: server === null || server === void 0 ? void 0 : server.baseUrl
-        });
-      }
-    }
-    return intermediateOptions;
-  }
-  return false;
-};
-const openRouteSSR = (routes, entries = []) => routes.map((ssgRoute) => ({
-  ...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({
-        ...route,
-        path: path2
-      });
-    }
-    if (route.children) {
-      parents.push({
-        ...route,
-        path: path2
-      });
-      route.children.forEach(traverseRoute);
-      parents.pop();
-    }
-  };
-  routes.forEach(traverseRoute);
-  return newRoutes;
-};
-function chunkArray(arr, size) {
-  const result = [];
-  for (let i = 0; i < arr.length; i += size) {
-    result.push(arr.slice(i, i + size));
-  }
-  return result;
-}
-export {
-  chunkArray,
-  flattenRoutes,
-  formatOutput,
-  formatPath,
-  getOutput,
-  getUrlPrefix,
-  isDynamicUrl,
-  openRouteSSR,
-  readJSONSpec,
-  replaceWithAlias,
-  standardOptions,
-  writeJSONSpec
-};

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

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

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

@@ -1,62 +0,0 @@
-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) => {
-  var _cp_stderr, _cp_stdout;
-  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.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: path.join(appContext.distDirectory, path.relative(appContext.appDirectory, appContext.apiDirectory)),
-      lambdaDirectory: path.join(appContext.distDirectory, path.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(CLOSE_SIGN);
-      resolve(htmlAry);
-    }
-  });
-  (_cp_stderr = cp.stderr) === null || _cp_stderr === void 0 ? void 0 : _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 = cp.stdout) === null || _cp_stdout === void 0 ? void 0 : _cp_stdout.on("data", (chunk) => {
-    const str = chunk.toString();
-    logger.info(str.replace(/[^\S\n]+/g, " "));
-  });
-});
-export {
-  createServer
-};

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

@@ -1,37 +0,0 @@
-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

@@ -1,85 +0,0 @@
-import assert from "node:assert";
-import { request } from "node:http";
-import { createProdServer, loadServerPlugins } from "@modern-js/prod-server";
-import { createLogger } from "@modern-js/utils";
-import portfinder from "portfinder";
-import { chunkArray } from "../libs/util";
-import { CLOSE_SIGN } from "./consts";
-function getLogger() {
-  const logger = createLogger({
-    level: "verbose"
-  });
-  return {
-    ...logger,
-    error: (...args) => {
-      console.error(...args);
-    }
-  };
-}
-const MAX_CONCURRENT_REQUESTS = 10;
-process.on("message", async (chunk) => {
-  if (chunk === CLOSE_SIGN) {
-    process.exit();
-  }
-  const context = JSON.parse(chunk);
-  const { routes, renderRoutes, options, appContext, plugins, distDirectory } = context;
-  let nodeServer = null;
-  try {
-    const { server: serverConfig } = options;
-    const defaultPort = Number(process.env.PORT) || serverConfig.port;
-    portfinder.basePort = defaultPort;
-    const port = await portfinder.getPortPromise();
-    const serverOptions = {
-      pwd: distDirectory,
-      config: options,
-      appContext,
-      // TODO
-      serverConfigPath: "",
-      routes,
-      plugins: await loadServerPlugins(plugins, appContext.appDirectory || distDirectory),
-      staticGenerate: true,
-      logger: getLogger()
-    };
-    assert(process.send, "process.send is not available");
-    const sendProcessMessage = process.send.bind(process);
-    nodeServer = await createProdServer(serverOptions);
-    nodeServer.listen(port, async () => {
-      if (!nodeServer)
-        return;
-      const chunkedRoutes = chunkArray(renderRoutes, MAX_CONCURRENT_REQUESTS);
-      for (const routes2 of chunkedRoutes) {
-        const promises = routes2.map(async (route) => getHtml(`http://localhost:${port}${route.urlPath}`, port));
-        for (const result of await Promise.all(promises)) {
-          sendProcessMessage(result);
-          sendProcessMessage(null);
-        }
-      }
-      nodeServer.close();
-    });
-  } catch (e) {
-    nodeServer === null || nodeServer === void 0 ? void 0 : nodeServer.close();
-    process.stderr.write(e instanceof Error ? e.stack : e.toString());
-  }
-});
-function getHtml(url, port) {
-  const headers = {
-    host: `localhost:${port}`
-  };
-  return new Promise((resolve, reject) => {
-    request(url, {
-      headers
-    }, (res) => {
-      const chunks = [];
-      res.on("error", (error) => {
-        reject(error);
-      });
-      res.on("data", (chunk) => {
-        chunks.push(chunk);
-      });
-      res.on("end", () => {
-        const html = Buffer.concat(chunks).toString();
-        resolve(html);
-      });
-    }).end();
-  });
-}

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

@@ -1 +0,0 @@
-export {};