@modern-js/plugin-ssg 2.0.0-beta.3 → 2.0.0-beta.6

package/dist/js/treeshaking/libs/output.js

@@ -0,0 +1,13 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+function writeHtmlFile(htmlAry, ssgRoutes, baseDir) {
+    htmlAry.forEach(function(html, index) {
+        var ssgRoute = ssgRoutes[index];
+        var 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/treeshaking/libs/replace.js

@@ -0,0 +1,115 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+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 _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+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 _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import normalize from "normalize-path";
+function exist(route, pageRoutes) {
+    return pageRoutes.slice().findIndex(function(pageRoute) {
+        var urlEqual = normalize(pageRoute.urlPath) === normalize(route.urlPath);
+        var entryEqual = pageRoute.entryName === route.entryName;
+        if (urlEqual && entryEqual) {
+            return true;
+        }
+        return false;
+    });
+}
+function replaceRoute(ssgRoutes, pageRoutes) {
+    var _pageRoutes;
+    var cleanSsgRoutes = ssgRoutes.map(function(ssgRoute) {
+        var output = ssgRoute.output, headers = ssgRoute.headers, cleanSsgRoute = _objectWithoutProperties(ssgRoute, [
+            "output",
+            "headers"
+        ]);
+        return Object.assign(cleanSsgRoute, output ? {
+            entryPath: output
+        } : {});
+    });
+    var freshRoutes = [];
+    cleanSsgRoutes.forEach(function(ssgRoute) {
+        var index = exist(ssgRoute, pageRoutes);
+        if (index < 0) {
+            freshRoutes.push(_objectSpread({}, ssgRoute));
+        } else {
+            pageRoutes[index].entryPath = ssgRoute.entryPath;
+        }
+    });
+    (_pageRoutes = pageRoutes).push.apply(_pageRoutes, _toConsumableArray(freshRoutes));
+    return pageRoutes;
+}
+export { exist, replaceRoute };

package/dist/js/treeshaking/libs/util.js

@@ -0,0 +1,239 @@
+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;
+}
+import path from "path";
+import { ROUTE_SPEC_FILE, fs, isSingleEntry, SERVER_BUNDLE_DIRECTORY } from "@modern-js/utils";
+function formatOutput(filename) {
+    var outputPath = path.extname(filename) ? filename : "".concat(filename, "/index.html");
+    return outputPath;
+}
+function formatPath(str) {
+    var addr = str;
+    if (!addr || typeof addr !== "string") {
+        return addr;
+    }
+    if (addr.startsWith(".")) {
+        addr = addr.slice(1);
+    }
+    if (!addr.startsWith("/")) {
+        addr = "/".concat(addr);
+    }
+    if (addr.endsWith("/") && addr !== "/") {
+        addr = addr.slice(0, addr.length - 1);
+    }
+    return addr;
+}
+function isDynamicUrl(url) {
+    return url.includes(":");
+}
+function getUrlPrefix(route, baseUrl) {
+    var base = "";
+    if (Array.isArray(baseUrl)) {
+        var filters = baseUrl.filter(function(url) {
+            return route.urlPath.includes(url);
+        });
+        if (filters.length > 1) {
+            var matched = filters.sort(function(a, b) {
+                return a.length - b.length;
+            })[0];
+            if (!matched) {
+                throw new Error("");
+            }
+            base = matched;
+        }
+    } else {
+        base = baseUrl;
+    }
+    base = base === "/" ? "" : base;
+    var entryName = route.entryName === "main" ? "" : route.entryName;
+    var prefix = "".concat(base, "/").concat(entryName);
+    return prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+}
+function getOutput(route, base, agreed) {
+    var output = route.output;
+    if (output) {
+        return output;
+    }
+    if (agreed) {
+        var urlWithoutBase = route.urlPath.replace(base, "");
+        return urlWithoutBase.startsWith("/") ? urlWithoutBase.slice(1) : urlWithoutBase;
+    }
+    throw new Error("routing must provide output when calling createPage(), check ".concat(route.urlPath));
+}
+var readJSONSpec = function(dir) {
+    var routeJSONPath = path.join(dir, ROUTE_SPEC_FILE);
+    var routeJSON = require(routeJSONPath);
+    var routes = routeJSON.routes;
+    return routes;
+};
+var writeJSONSpec = function(dir, routes) {
+    var routeJSONPath = path.join(dir, ROUTE_SPEC_FILE);
+    fs.writeJSONSync(routeJSONPath, {
+        routes: routes
+    }, {
+        spaces: 2
+    });
+};
+var replaceWithAlias = function(base, filePath, alias) {
+    return path.posix.join(alias, path.posix.relative(base, filePath));
+};
+var standardOptions = function(ssgOptions, entrypoints, routes, server) {
+    if (ssgOptions === false) {
+        return false;
+    }
+    if (ssgOptions === true) {
+        return entrypoints.reduce(function(opt, entry) {
+            opt[entry.entryName] = ssgOptions;
+            return opt;
+        }, {});
+    } else if (typeof ssgOptions === "object") {
+        var isSingle = isSingleEntry(entrypoints);
+        if (isSingle && typeof ssgOptions.main === "undefined") {
+            return {
+                main: ssgOptions
+            };
+        } else {
+            return ssgOptions;
+        }
+    } else if (typeof ssgOptions === "function") {
+        var intermediateOptions = {};
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var entrypoint = _step.value;
+                var entryName = entrypoint.entryName;
+                if (Array.isArray(server === null || server === void 0 ? void 0 : server.baseUrl)) {
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        var _loop = function() {
+                            var url = _step1.value;
+                            var matchUrl = entryName === "main" ? url : "".concat(url, "/").concat(entryName);
+                            var route = routes.find(function(route2) {
+                                return route2.urlPath === matchUrl;
+                            });
+                            intermediateOptions[route === null || route === void 0 ? void 0 : route.urlPath] = ssgOptions(entryName, {
+                                baseUrl: url
+                            });
+                        };
+                        for(var _iterator = server.baseUrl[Symbol.iterator](), _step1; !(_iteratorNormalCompletion = (_step1 = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                } else {
+                    intermediateOptions[entryName] = ssgOptions(entryName, {
+                        baseUrl: server === null || server === void 0 ? void 0 : server.baseUrl
+                    });
+                }
+            };
+            for(var _iterator = entrypoints[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        return intermediateOptions;
+    }
+    return false;
+};
+var openRouteSSR = function(routes) {
+    var entries = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+    return routes.map(function(ssgRoute) {
+        return _objectSpreadProps(_objectSpread({}, ssgRoute), {
+            isSSR: entries.includes(ssgRoute.entryName),
+            bundle: "".concat(SERVER_BUNDLE_DIRECTORY, "/").concat(ssgRoute.entryName, ".js")
+        });
+    });
+};
+var flattenRoutes = function(routes) {
+    var parents = [];
+    var newRoutes = [];
+    var traverseRoute = function(route) {
+        var parent = parents[parents.length - 1];
+        var path2 = parent ? "".concat(parent.path, "/").concat(route.path || "").replace(/\/+/g, "/") : route.path || "";
+        path2 = path2.replace(/\/$/, "");
+        if (route._component && (path2 !== "/" || path2 === "/" && !parent)) {
+            newRoutes.push(_objectSpreadProps(_objectSpread({}, route), {
+                path: path2
+            }));
+        }
+        if (route.children) {
+            parents.push(_objectSpreadProps(_objectSpread({}, 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/treeshaking/server/consts.js

@@ -0,0 +1,2 @@
+var CLOSE_SIGN = "modern_close_server";
+export { CLOSE_SIGN };

package/dist/js/treeshaking/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";
+var createServer = function(api, ssgRoutes, pageRoutes, apiRoutes, options, appDirectory) {
+    return new Promise(function(resolve, reject) {
+        var entries = ssgRoutes.map(function(route) {
+            return route.entryName;
+        });
+        var backup = openRouteSSR(pageRoutes, entries);
+        var total = backup.concat(apiRoutes);
+        var cp = childProcess.fork(path.join(__dirname, "process"), {
+            cwd: appDirectory,
+            silent: true
+        });
+        var appContext = api.useAppContext();
+        var plugins = appContext.serverInternalPlugins;
+        cp.send(JSON.stringify({
+            options: options,
+            renderRoutes: ssgRoutes,
+            routes: total,
+            appDirectory: appDirectory,
+            plugins: plugins
+        }));
+        var htmlChunks = [];
+        var htmlAry = [];
+        cp.on("message", function(chunk) {
+            if (chunk !== null) {
+                htmlChunks.push(chunk);
+            } else {
+                var html = htmlChunks.join("");
+                htmlAry.push(html);
+                htmlChunks.length = 0;
+            }
+            if (htmlAry.length === ssgRoutes.length) {
+                cp.send(CLOSE_SIGN);
+                resolve(htmlAry);
+            }
+        });
+        cp.stderr.on("data", function(chunk) {
+            var 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", function(chunk) {
+            var 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/treeshaking/server/prerender.js

@@ -0,0 +1,97 @@
+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 _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+import EventEmitter from "events";
+import { Readable } from "stream";
+import httpMocks from "node-mocks-http";
+var compile = function(requestHandler) {
+    return function(options) {
+        var extend = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        return new Promise(function(resolve, reject) {
+            var req = httpMocks.createRequest(_objectSpreadProps(_objectSpread({}, options), {
+                eventEmitter: Readable
+            }));
+            var res = httpMocks.createResponse({
+                eventEmitter: EventEmitter
+            });
+            Object.assign(req, extend);
+            var proxyRes = new Proxy(res, {
+                get: function get(obj, prop) {
+                    if ((typeof prop === "undefined" ? "undefined" : _typeof(prop)) === "symbol" && !obj[prop]) {
+                        return null;
+                    }
+                    return obj[prop];
+                }
+            });
+            res.on("finish", function() {
+                if (res.statusCode !== 200) {
+                    reject(new Error(res.statusMessage));
+                } else {
+                    resolve(res._getData());
+                }
+            });
+            res.on("error", function(e) {
+                return reject(e);
+            });
+            try {
+                requestHandler(req, proxyRes);
+            } catch (e) {
+                reject(e);
+            }
+        });
+    };
+};
+export { compile };