@modern-js/plugin-ssg 0.0.0-next-45d726979 → 0.0.0-next-0bf5ec13d2

package/dist/js/node/libs/util.js

@@ -0,0 +1,203 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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 __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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var util_exports = {};
+__export(util_exports, {
+  flattenRoutes: () => flattenRoutes,
+  formatOutput: () => formatOutput,
+  formatPath: () => formatPath,
+  getOutput: () => getOutput,
+  getUrlPrefix: () => getUrlPrefix,
+  isDynamicUrl: () => isDynamicUrl,
+  openRouteSSR: () => openRouteSSR,
+  readJSONSpec: () => readJSONSpec,
+  replaceWithAlias: () => replaceWithAlias,
+  standardOptions: () => standardOptions,
+  writeJSONSpec: () => writeJSONSpec
+});
+module.exports = __toCommonJS(util_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+function formatOutput(filename) {
+  const outputPath = import_path.default.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 = import_path.default.join(dir, import_utils.ROUTE_SPEC_FILE);
+  const routeJSON = require(routeJSONPath);
+  const { routes } = routeJSON;
+  return routes;
+};
+const writeJSONSpec = (dir, routes) => {
+  const routeJSONPath = import_path.default.join(dir, import_utils.ROUTE_SPEC_FILE);
+  import_utils.fs.writeJSONSync(routeJSONPath, { routes }, { spaces: 2 });
+};
+const replaceWithAlias = (base, filePath, alias) => import_path.default.posix.join(alias, import_path.default.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 = (0, import_utils.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: `${import_utils.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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flattenRoutes,
+  formatOutput,
+  formatPath,
+  getOutput,
+  getUrlPrefix,
+  isDynamicUrl,
+  openRouteSSR,
+  readJSONSpec,
+  replaceWithAlias,
+  standardOptions,
+  writeJSONSpec
+});

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

@@ -0,0 +1,27 @@
+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 consts_exports = {};
+__export(consts_exports, {
+  CLOSE_SIGN: () => CLOSE_SIGN
+});
+module.exports = __toCommonJS(consts_exports);
+const CLOSE_SIGN = "modern_close_server";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLOSE_SIGN
+});

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

@@ -0,0 +1,92 @@
+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(
+  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
+});
+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) => {
+  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.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(import_consts.CLOSE_SIGN);
+      resolve(htmlAry);
+    }
+  });
+  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.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, " "));
+    }
+  });
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServer
+});

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

@@ -0,0 +1,80 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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 __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(
+  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
+});
+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(__spreadProps(__spreadValues({}, 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
+});

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

@@ -0,0 +1,93 @@
+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 __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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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());
+  });
+};
+var import_prod_server = __toESM(require("@modern-js/prod-server"));
+var import_portfinder = __toESM(require("portfinder"));
+var import_make = require("../libs/make");
+var import_prerender = require("./prerender");
+var import_consts = require("./consts");
+process.on("message", (chunk) => __async(exports, null, function* () {
+  if (chunk === import_consts.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;
+    import_portfinder.default.basePort = defaultPort;
+    const port = yield import_portfinder.default.getPortPromise();
+    modernServer = yield (0, import_prod_server.default)({
+      pwd: appDirectory,
+      config: options,
+      routes,
+      staticGenerate: true,
+      internalPlugins: plugins
+    });
+    modernServer.listen(port, (err) => __async(exports, null, function* () {
+      if (err) {
+        throw err;
+      }
+      if (!modernServer) {
+        return;
+      }
+      const render = (0, import_prerender.compile)(modernServer.getRequestHandler());
+      const renderPromiseAry = (0, import_make.makeRender)(
+        renderRoutes,
+        render,
+        port
+      );
+      const htmlAry = yield 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/js/node/types.js

@@ -0,0 +1,15 @@
+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);