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

package/dist/js/treeshaking/index.js

@@ -0,0 +1,334 @@
+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) || true;
+                                    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 _entryOptions_preventDefault = entryOptions.preventDefault, preventDefault = _entryOptions_preventDefault === void 0 ? [] : _entryOptions_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 };

package/dist/js/treeshaking/libs/make.js

@@ -0,0 +1,83 @@
+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 normalize from "normalize-path";
+function makeRender(ssgRoutes, render, port) {
+    return ssgRoutes.map(function(ssgRoute) {
+        return render({
+            url: ssgRoute.urlPath,
+            headers: _objectSpread({
+                host: "localhost:".concat(port)
+            }, ssgRoute.headers),
+            connection: {}
+        });
+    });
+}
+function makeRoute(baseRoute, route) {
+    var headers = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    var urlPath = baseRoute.urlPath, entryPath = baseRoute.entryPath;
+    if (typeof route === "string") {
+        return _objectSpreadProps(_objectSpread({}, baseRoute), {
+            urlPath: normalize("".concat(urlPath).concat(route)) || "/",
+            headers: headers,
+            output: path.join(entryPath, "..".concat(route === "/" ? "" : route))
+        });
+    } else {
+        return _objectSpreadProps(_objectSpread({}, baseRoute), {
+            urlPath: normalize("".concat(urlPath).concat(route.url)) || "/",
+            headers: _objectSpread({}, headers, route.headers),
+            output: route.output ? path.normalize(route.output) : path.join(entryPath, "..".concat(route.url === "/" ? "" : route.url))
+        });
+    }
+}
+export { makeRender, makeRoute };

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 };