@modern-js/plugin-ssg 2.0.0-beta.2 → 2.0.0-beta.4

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

@@ -1,44 +1,78 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 stdin_exports = {};
+__export(stdin_exports, {
+  compile: () => compile
 });
-exports.compile = void 0;
-var _events = _interopRequireDefault(require("events"));
-var _stream = require("stream");
-var _nodeMocksHttp = _interopRequireDefault(require("node-mocks-http"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-const compile = requestHandler => (options, extend = {}) => new Promise((resolve, reject) => {
-  const req = _nodeMocksHttp.default.createRequest(_objectSpread(_objectSpread({}, options), {}, {
-    eventEmitter: _stream.Readable
+module.exports = __toCommonJS(stdin_exports);
+var import_events = __toESM(require("events"));
+var import_stream = require("stream");
+var import_node_mocks_http = __toESM(require("node-mocks-http"));
+var __defProp2 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp2.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));
+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 = _nodeMocksHttp.default.createResponse({
-    eventEmitter: _events.default
-  });
+  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]) {
+      if (typeof prop === "symbol" && !obj[prop]) {
         return null;
       }
       return obj[prop];
     }
   });
-  res.on('finish', () => {
+  res.on("finish", () => {
     if (res.statusCode !== 200) {
       reject(new Error(res.statusMessage));
     } else {
       resolve(res._getData());
     }
   });
-  res.on('error', e => reject(e));
+  res.on("error", (e) => reject(e));
   try {
     requestHandler(req, proxyRes);
   } catch (e) {
     reject(e);
   }
 });
-exports.compile = compile;

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

@@ -1,66 +1,112 @@
-"use strict";
-
-var _prodServer = _interopRequireDefault(require("@modern-js/prod-server"));
-var _portfinder = _interopRequireDefault(require("portfinder"));
-var _make = require("../libs/make");
-var _prerender = require("./prerender");
-var _consts = require("./consts");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-process.on('message', async chunk => {
-  if (chunk === _consts.CLOSE_SIGN) {
-    // eslint-disable-next-line no-process-exit
-    process.exit();
+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 });
   }
-  const context = JSON.parse(chunk);
-  const {
-    routes,
-    renderRoutes,
-    options,
-    appDirectory,
-    plugins
-  } = context;
-  let modernServer = null;
-  try {
-    const {
-      server: serverOptions
-    } = options;
-
-    // start server in default port
-    const defaultPort = Number(process.env.PORT) || serverOptions.port;
-    _portfinder.default.basePort = defaultPort;
-    const port = await _portfinder.default.getPortPromise();
-    modernServer = await (0, _prodServer.default)({
-      pwd: appDirectory,
-      config: options,
-      routes,
-      staticGenerate: true,
-      internalPlugins: plugins
-    });
-
-    // listen just for bff request in ssr page
-    modernServer.listen(port, async err => {
-      if (err) {
-        throw err;
+  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 stdin_exports = {};
+__export(stdin_exports, {
+  default: () => stdin_default
+});
+module.exports = __toCommonJS(stdin_exports);
+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");
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
       }
-      if (!modernServer) {
-        return;
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
       }
-
-      // get server handler, render to ssr
-      const render = (0, _prerender.compile)(modernServer.getRequestHandler());
-      const renderPromiseAry = (0, _make.makeRender)(renderRoutes, render, port);
-
-      // eslint-disable-next-line promise/no-promise-in-callback
-      const htmlAry = await Promise.all(renderPromiseAry);
-      htmlAry.forEach(html => {
-        process.send(html);
-        process.send(null);
-      });
-      modernServer.close();
-    });
-  } catch (e) {
-    var _modernServer;
-    (_modernServer = modernServer) === null || _modernServer === void 0 ? void 0 : _modernServer.close();
-    throw e;
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var require_process = __commonJS({
+  "src/server/process.ts"(exports) {
+    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;
+      }
+    }));
   }
-});
+});
+var stdin_default = require_process();

package/dist/js/node/types.js

@@ -1,5 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});

package/dist/js/treeshaking/global.d.js

@@ -0,0 +1 @@
+"use strict";

package/dist/js/treeshaking/index.js

@@ -0,0 +1,339 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+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 = function() {
+    return {
+        name: "@modern-js/plugin-ssg",
+        pre: [
+            "@modern-js/plugin-server",
+            "@modern-js/plugin-bff"
+        ],
+        setup: function(api) {
+            var agreedRouteMap = {};
+            return {
+                validateSchema: function validateSchema() {
+                    return PLUGIN_SCHEMAS["@modern-js/plugin-ssg"];
+                },
+                modifyFileSystemRoutes: function modifyFileSystemRoutes(param) {
+                    var entrypoint = param.entrypoint, routes = param.routes;
+                    var entryName = entrypoint.entryName;
+                    var flattedRoutes = flattenRoutes(routes);
+                    agreedRouteMap[entryName] = flattedRoutes;
+                    return {
+                        entrypoint: entrypoint,
+                        routes: routes
+                    };
+                },
+                afterBuild: function afterBuild() {
+                    return _asyncToGenerator(function() {
+                        var resolvedConfig, appContext, appDirectory, entrypoints, output, server, ssg, tmp, ref, outputPath, ssgOptions, buildDir, routes, pageRoutes, apiRoutes, intermediateOptions, ssgRoutes, htmlAry;
+                        return __generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    resolvedConfig = api.useResolvedConfigContext();
+                                    appContext = api.useAppContext();
+                                    appDirectory = appContext.appDirectory, entrypoints = appContext.entrypoints;
+                                    output = resolvedConfig.output, server = resolvedConfig.server;
+                                    ssg = output.ssg, tmp = output.distPath, ref = tmp === void 0 ? {} : tmp, outputPath = ref.root;
+                                    ssgOptions = Array.isArray(ssg) ? ssg.pop() : ssg;
+                                    if (!ssgOptions) {
+                                        return [
+                                            2
+                                        ];
+                                    }
+                                    buildDir = path.join(appDirectory, outputPath);
+                                    routes = readJSONSpec(buildDir);
+                                    pageRoutes = routes.filter(function(route) {
+                                        return !route.isApi;
+                                    });
+                                    apiRoutes = routes.filter(function(route) {
+                                        return route.isApi;
+                                    });
+                                    if (pageRoutes.length === 0) {
+                                        return [
+                                            2
+                                        ];
+                                    }
+                                    intermediateOptions = standardOptions(ssgOptions, entrypoints, pageRoutes, server);
+                                    if (!intermediateOptions) {
+                                        return [
+                                            2
+                                        ];
+                                    }
+                                    ssgRoutes = [];
+                                    pageRoutes.forEach(function(pageRoute) {
+                                        var entryName = pageRoute.entryName, entryPath = pageRoute.entryPath;
+                                        var agreedRoutes = agreedRouteMap[entryName];
+                                        var entryOptions = intermediateOptions[entryName] || intermediateOptions[pageRoute.urlPath];
+                                        if (!agreedRoutes) {
+                                            if (!entryOptions) {
+                                                return;
+                                            }
+                                            if (entryOptions === true) {
+                                                ssgRoutes.push(_objectSpreadProps(_objectSpread({}, pageRoute), {
+                                                    output: entryPath
+                                                }));
+                                            } else if (entryOptions.routes && entryOptions.routes.length > 0) {
+                                                var enrtyRoutes = entryOptions.routes, headers = entryOptions.headers;
+                                                enrtyRoutes.forEach(function(route) {
+                                                    ssgRoutes.push(makeRoute(pageRoute, route, headers));
+                                                });
+                                            }
+                                        } else {
+                                            if (!entryOptions) {
+                                                return;
+                                            }
+                                            if (entryOptions === true) {
+                                                entryOptions = {
+                                                    preventDefault: [],
+                                                    routes: [],
+                                                    headers: {}
+                                                };
+                                            }
+                                            var _preventDefault = entryOptions.preventDefault, preventDefault = _preventDefault === void 0 ? [] : _preventDefault, tmp = entryOptions.routes, userRoutes = tmp === void 0 ? [] : tmp, headers1 = entryOptions.headers;
+                                            if (userRoutes.length > 0) {
+                                                userRoutes.forEach(function(route) {
+                                                    if (typeof route === "string") {
+                                                        ssgRoutes.push(makeRoute(pageRoute, route, headers1));
+                                                    } else if (Array.isArray(route.params)) {
+                                                        route.params.forEach(function(param) {
+                                                            ssgRoutes.push(makeRoute(pageRoute, _objectSpreadProps(_objectSpread({}, route), {
+                                                                url: generatePath(route.url, param)
+                                                            }), headers1));
+                                                        });
+                                                    } else {
+                                                        ssgRoutes.push(makeRoute(pageRoute, route, headers1));
+                                                    }
+                                                });
+                                            } else {
+                                                agreedRoutes.filter(function(route) {
+                                                    return !preventDefault.includes(route.path);
+                                                }).forEach(function(route) {
+                                                    if (!isDynamicUrl(route.path)) {
+                                                        ssgRoutes.push(makeRoute(pageRoute, route.path, headers1));
+                                                    }
+                                                });
+                                            }
+                                        }
+                                    });
+                                    if (ssgRoutes.length === 0) {
+                                        return [
+                                            2
+                                        ];
+                                    }
+                                    ssgRoutes.forEach(function(ssgRoute) {
+                                        if (ssgRoute.isSSR) {
+                                            var isOriginRoute = pageRoutes.some(function(pageRoute) {
+                                                return pageRoute.urlPath === ssgRoute.urlPath && pageRoute.entryName === ssgRoute.entryName;
+                                            });
+                                            if (isOriginRoute) {
+                                                throw new Error("ssg can not using with ssr，url - ".concat(ssgRoute.urlPath, ", entry - ").concat(ssgRoute.entryName, " "));
+                                            }
+                                            logger.warn("new ssg route ".concat(ssgRoute.urlPath, " is using ssr now，maybe from parent route ").concat(ssgRoute.entryName, "，close ssr"));
+                                        }
+                                        ssgRoute.isSSR = false;
+                                        ssgRoute.output = formatOutput(ssgRoute.output);
+                                    });
+                                    return [
+                                        4,
+                                        createServer(api, ssgRoutes, pageRoutes, apiRoutes, resolvedConfig, appDirectory)
+                                    ];
+                                case 1:
+                                    htmlAry = _state.sent();
+                                    writeHtmlFile(htmlAry, ssgRoutes, buildDir);
+                                    replaceRoute(ssgRoutes, pageRoutes);
+                                    writeJSONSpec(buildDir, pageRoutes.concat(apiRoutes));
+                                    logger.info("ssg Compiled successfully");
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    })();
+                }
+            };
+        }
+    };
+};
+export { src_default as default };