@bleedingdev/modern-js-plugin-ssg 3.2.0-ultramodern.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/dist/cjs/index.js

@@ -0,0 +1,136 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>src,
+    ssgPlugin: ()=>ssgPlugin
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const make_js_namespaceObject = require("./libs/make.js");
+const output_js_namespaceObject = require("./libs/output.js");
+const replace_js_namespaceObject = require("./libs/replace.js");
+const util_js_namespaceObject = require("./libs/util.js");
+const index_js_namespaceObject = require("./server/index.js");
+const ssgPlugin = ()=>({
+        name: '@modern-js/plugin-ssg',
+        pre: [
+            '@modern-js/plugin-bff'
+        ],
+        setup: (api)=>{
+            const agreedRouteMap = {};
+            api.modifyFileSystemRoutes(async ({ entrypoint, routes })=>{
+                const { entryName } = entrypoint;
+                const flattedRoutes = (0, util_js_namespaceObject.flattenRoutes)((0, utils_namespaceObject.filterRoutesForServer)(routes));
+                agreedRouteMap[entryName] = flattedRoutes;
+                return {
+                    entrypoint,
+                    routes
+                };
+            });
+            api.onAfterBuild(async ()=>{
+                const resolvedConfig = api.getNormalizedConfig();
+                const appContext = api.getAppContext();
+                const { appDirectory, entrypoints } = appContext;
+                const { output, server } = resolvedConfig;
+                const { ssg, ssgByEntries, distPath: { root: outputPath } = {} } = output;
+                const ssgOptions = (Array.isArray(ssg) ? ssg.pop() : ssg) ?? true;
+                const buildDir = external_path_default().join(appDirectory, outputPath);
+                const routes = (0, util_js_namespaceObject.readJSONSpec)(buildDir);
+                const pageRoutes = routes.filter((route)=>route.isSPA);
+                const apiRoutes = routes.filter((route)=>!route.isSPA);
+                if (0 === pageRoutes.length) return;
+                const intermediateOptions = (0, util_js_namespaceObject.standardOptions)(ssgOptions, entrypoints, pageRoutes, server, ssgByEntries);
+                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 (true === entryOptions) entryOptions = {
+                            routes: [],
+                            headers: {}
+                        };
+                        const { routes: userRoutes = [], headers } = entryOptions || {};
+                        if (userRoutes.length > 0) userRoutes.forEach((route)=>{
+                            ssgRoutes.push((0, make_js_namespaceObject.makeRoute)(pageRoute, route, headers));
+                        });
+                        else agreedRoutes.forEach((route)=>{
+                            if (!(0, util_js_namespaceObject.isDynamicUrl)(route.path)) ssgRoutes.push((0, make_js_namespaceObject.makeRoute)(pageRoute, route.path, headers));
+                        });
+                    } else {
+                        if (!entryOptions) return;
+                        if (true === entryOptions) ssgRoutes.push({
+                            ...pageRoute,
+                            output: entryPath
+                        });
+                        else if (entryOptions.routes && entryOptions.routes.length > 0) {
+                            const { routes: enrtyRoutes, headers } = entryOptions;
+                            enrtyRoutes.forEach((route)=>{
+                                ssgRoutes.push((0, make_js_namespaceObject.makeRoute)(pageRoute, route, headers));
+                            });
+                        }
+                    }
+                });
+                if (0 === ssgRoutes.length) 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} `);
+                        utils_namespaceObject.logger.warn(`new ssg route ${ssgRoute.urlPath} is using ssr now，maybe from parent route ${ssgRoute.entryName}，close ssr`);
+                    }
+                    ssgRoute.isSSR = false;
+                    ssgRoute.output = (0, util_js_namespaceObject.formatOutput)(ssgRoute.output);
+                });
+                const htmlAry = await (0, index_js_namespaceObject.createServer)(appContext, ssgRoutes, pageRoutes, apiRoutes, resolvedConfig);
+                (0, output_js_namespaceObject.writeHtmlFile)(htmlAry, ssgRoutes, buildDir);
+                (0, replace_js_namespaceObject.replaceRoute)(ssgRoutes, pageRoutes);
+                (0, util_js_namespaceObject.writeJSONSpec)(buildDir, pageRoutes.concat(apiRoutes));
+                utils_namespaceObject.logger.info('ssg Compiled successfully');
+            });
+        }
+    });
+const src = ssgPlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.ssgPlugin = __webpack_exports__.ssgPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "ssgPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/libs/make.js

@@ -0,0 +1,79 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    makeRender: ()=>makeRender,
+    makeRoute: ()=>makeRoute
+});
+const external_normalize_path_namespaceObject = require("normalize-path");
+var external_normalize_path_default = /*#__PURE__*/ __webpack_require__.n(external_normalize_path_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+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 ('string' == typeof route) return {
+        ...baseRoute,
+        urlPath: external_normalize_path_default()(`${urlPath}${route}`) || '/',
+        headers,
+        output: external_path_default().join(entryPath, `..${'/' === route ? '' : route}`)
+    };
+    return {
+        ...baseRoute,
+        urlPath: external_normalize_path_default()(`${urlPath}${route.url}`) || '/',
+        headers: {
+            ...headers,
+            ...route.headers
+        },
+        output: route.output ? external_path_default().normalize(route.output) : external_path_default().join(entryPath, `..${'/' === route.url ? '' : route.url}`)
+    };
+}
+exports.makeRender = __webpack_exports__.makeRender;
+exports.makeRoute = __webpack_exports__.makeRoute;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "makeRender",
+    "makeRoute"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/libs/output.js

@@ -0,0 +1,55 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    writeHtmlFile: ()=>writeHtmlFile
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+function writeHtmlFile(htmlAry, ssgRoutes, baseDir) {
+    htmlAry.forEach((html, index)=>{
+        const ssgRoute = ssgRoutes[index];
+        const filepath = external_path_default().join(baseDir, ssgRoute.output);
+        if (!utils_namespaceObject.fs.existsSync(external_path_default().dirname(filepath))) utils_namespaceObject.fs.ensureDirSync(external_path_default().dirname(filepath));
+        utils_namespaceObject.fs.writeFileSync(filepath, html);
+    });
+}
+exports.writeHtmlFile = __webpack_exports__.writeHtmlFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "writeHtmlFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/libs/replace.js

@@ -0,0 +1,75 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    exist: ()=>exist,
+    replaceRoute: ()=>replaceRoute
+});
+const external_normalize_path_namespaceObject = require("normalize-path");
+var external_normalize_path_default = /*#__PURE__*/ __webpack_require__.n(external_normalize_path_namespaceObject);
+function exist(route, pageRoutes) {
+    return pageRoutes.slice().findIndex((pageRoute)=>{
+        const urlEqual = external_normalize_path_default()(pageRoute.urlPath) === external_normalize_path_default()(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;
+}
+exports.exist = __webpack_exports__.exist;
+exports.replaceRoute = __webpack_exports__.replaceRoute;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "exist",
+    "replaceRoute"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/libs/util.js

@@ -0,0 +1,224 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    chunkArray: ()=>chunkArray,
+    flattenRoutes: ()=>flattenRoutes,
+    formatOutput: ()=>formatOutput,
+    formatPath: ()=>formatPath,
+    getOutput: ()=>getOutput,
+    getUrlPrefix: ()=>getUrlPrefix,
+    isDynamicUrl: ()=>isDynamicUrl,
+    openRouteSSR: ()=>openRouteSSR,
+    readJSONSpec: ()=>readJSONSpec,
+    replaceWithAlias: ()=>replaceWithAlias,
+    standardOptions: ()=>standardOptions,
+    writeJSONSpec: ()=>writeJSONSpec
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+function formatOutput(filename) {
+    const outputPath = external_path_default().extname(filename) ? filename : `${filename}/index.html`;
+    return outputPath;
+}
+function formatPath(str) {
+    let addr = str;
+    if (!addr || 'string' != typeof addr) 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(':') || url.endsWith('*');
+}
+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 = 'main' === route.entryName ? '' : 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 = external_path_default().join(dir, utils_namespaceObject.ROUTE_SPEC_FILE);
+    const routeJSON = require(routeJSONPath);
+    const { routes } = routeJSON;
+    return routes;
+};
+const writeJSONSpec = (dir, routes)=>{
+    const routeJSONPath = external_path_default().join(dir, utils_namespaceObject.ROUTE_SPEC_FILE);
+    utils_namespaceObject.fs.writeJSONSync(routeJSONPath, {
+        routes
+    }, {
+        spaces: 2
+    });
+};
+const replaceWithAlias = (base, filePath, alias)=>external_path_default().posix.join(alias, external_path_default().posix.relative(base, filePath));
+const standardOptions = (ssgOptions, entrypoints, routes, server, ssgByEntries)=>{
+    if (ssgByEntries && Object.keys(ssgByEntries).length > 0) {
+        const result = {};
+        Object.keys(ssgByEntries).forEach((key)=>{
+            const val = ssgByEntries[key];
+            if ('function' != typeof val) result[key] = val;
+        });
+        for (const entry of entrypoints){
+            const { entryName } = entry;
+            const configured = ssgByEntries[entryName];
+            if ('function' == typeof configured) {
+                const routesForEntry = routes.filter((r)=>r.entryName === entryName);
+                if (Array.isArray(server?.baseUrl)) for (const url of server.baseUrl)routesForEntry.filter((r)=>'string' == typeof r.urlPath && r.urlPath.startsWith(url)).forEach((r)=>{
+                    result[r.urlPath] = configured(entryName, {
+                        baseUrl: url
+                    });
+                });
+                else result[entryName] = configured(entryName, {
+                    baseUrl: server?.baseUrl
+                });
+            } else if (void 0 !== configured) result[entryName] = configured;
+        }
+        return result;
+    }
+    if (false === ssgOptions) return false;
+    if (true === ssgOptions) return entrypoints.reduce((opt, entry)=>{
+        opt[entry.entryName] = ssgOptions;
+        return opt;
+    }, {});
+    if ('object' == typeof ssgOptions) {
+        const isSingle = (0, utils_namespaceObject.isSingleEntry)(entrypoints);
+        if (isSingle) return {
+            main: ssgOptions
+        };
+        return entrypoints.reduce((opt, entry)=>{
+            opt[entry.entryName] = ssgOptions;
+            return opt;
+        }, {});
+    }
+    if ('function' == typeof ssgOptions) {
+        const intermediateOptions = {};
+        for (const entrypoint of entrypoints){
+            const { entryName } = entrypoint;
+            const routesForEntry = routes.filter((r)=>r.entryName === entryName);
+            if (Array.isArray(server?.baseUrl)) for (const url of server.baseUrl)routesForEntry.filter((r)=>'string' == typeof r.urlPath && r.urlPath.startsWith(url)).forEach((r)=>{
+                intermediateOptions[r.urlPath] = ssgOptions(entryName, {
+                    baseUrl: url
+                });
+            });
+            else intermediateOptions[entryName] = ssgOptions(entryName, {
+                baseUrl: server?.baseUrl
+            });
+        }
+        return intermediateOptions;
+    }
+    return false;
+};
+const openRouteSSR = (routes, entries = [])=>routes.map((ssgRoute)=>({
+            ...ssgRoute,
+            isSSR: entries.includes(ssgRoute.entryName),
+            bundle: `${utils_namespaceObject.SERVER_BUNDLE_DIRECTORY}/${ssgRoute.entryName}.js`
+        }));
+const flattenRoutes = (routes)=>{
+    const parents = [];
+    const newRoutes = [];
+    const traverseRoute = (route)=>{
+        const parent = parents[parents.length - 1];
+        let path = parent ? `${parent.path}/${route.path || ''}`.replace(/\/+/g, '/') : route.path || '';
+        path = path.replace(/\/$/, '');
+        if (route._component && ('/' !== path || '/' === path && !parent)) newRoutes.push({
+            ...route,
+            path
+        });
+        if (route.children) {
+            parents.push({
+                ...route,
+                path
+            });
+            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;
+}
+exports.chunkArray = __webpack_exports__.chunkArray;
+exports.flattenRoutes = __webpack_exports__.flattenRoutes;
+exports.formatOutput = __webpack_exports__.formatOutput;
+exports.formatPath = __webpack_exports__.formatPath;
+exports.getOutput = __webpack_exports__.getOutput;
+exports.getUrlPrefix = __webpack_exports__.getUrlPrefix;
+exports.isDynamicUrl = __webpack_exports__.isDynamicUrl;
+exports.openRouteSSR = __webpack_exports__.openRouteSSR;
+exports.readJSONSpec = __webpack_exports__.readJSONSpec;
+exports.replaceWithAlias = __webpack_exports__.replaceWithAlias;
+exports.standardOptions = __webpack_exports__.standardOptions;
+exports.writeJSONSpec = __webpack_exports__.writeJSONSpec;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "chunkArray",
+    "flattenRoutes",
+    "formatOutput",
+    "formatPath",
+    "getOutput",
+    "getUrlPrefix",
+    "isDynamicUrl",
+    "openRouteSSR",
+    "readJSONSpec",
+    "replaceWithAlias",
+    "standardOptions",
+    "writeJSONSpec"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server/consts.js

@@ -0,0 +1,36 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    CLOSE_SIGN: ()=>CLOSE_SIGN
+});
+const CLOSE_SIGN = 'modern_close_server';
+exports.CLOSE_SIGN = __webpack_exports__.CLOSE_SIGN;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CLOSE_SIGN"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});