@modern-js/plugin-ssg 2.69.4 → 3.0.0-alpha.0

package/dist/esm/libs/util.mjs

@@ -0,0 +1,147 @@
+import path_0 from "path";
+import { ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, fs, isSingleEntry } from "@modern-js/utils";
+function formatOutput(filename) {
+    const outputPath = path_0.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 = path_0.join(dir, ROUTE_SPEC_FILE);
+    const routeJSON = require(routeJSONPath);
+    const { routes } = routeJSON;
+    return routes;
+};
+const writeJSONSpec = (dir, routes)=>{
+    const routeJSONPath = path_0.join(dir, ROUTE_SPEC_FILE);
+    fs.writeJSONSync(routeJSONPath, {
+        routes
+    }, {
+        spaces: 2
+    });
+};
+const replaceWithAlias = (base, filePath, alias)=>path_0.posix.join(alias, path_0.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 = 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: `${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;
+}
+export { chunkArray, flattenRoutes, formatOutput, formatPath, getOutput, getUrlPrefix, isDynamicUrl, openRouteSSR, readJSONSpec, replaceWithAlias, standardOptions, writeJSONSpec };

package/dist/esm/server/consts.mjs

@@ -0,0 +1,2 @@
+const CLOSE_SIGN = 'modern_close_server';
+export { CLOSE_SIGN };

package/dist/esm/server/index.mjs

@@ -0,0 +1,97 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import path from "path";
+import { createProdServer, loadServerPlugins } from "@modern-js/prod-server";
+import { SERVER_DIR, createLogger, getMeta, logger } from "@modern-js/utils";
+import { chunkArray, openRouteSSR } from "../libs/util";
+function getLogger() {
+    const l = createLogger({
+        level: 'verbose'
+    });
+    return {
+        ...l,
+        error: (...args)=>{
+            console.error(...args);
+        }
+    };
+}
+const MAX_CONCURRENT_REQUESTS = 10;
+function createMockIncomingMessage(url, headers = {}) {
+    const urlObj = new URL(url);
+    const mockReq = new IncomingMessage({});
+    mockReq.url = urlObj.pathname + urlObj.search;
+    mockReq.method = 'GET';
+    mockReq.headers = {
+        host: urlObj.host,
+        'user-agent': 'SSG-Renderer/1.0',
+        accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'accept-language': 'en-US,en;q=0.5',
+        'accept-encoding': 'gzip, deflate',
+        connection: 'keep-alive',
+        ...headers
+    };
+    mockReq.httpVersion = '1.1';
+    mockReq.httpVersionMajor = 1;
+    mockReq.httpVersionMinor = 1;
+    mockReq.complete = true;
+    mockReq.rawHeaders = [];
+    mockReq.socket = {};
+    mockReq.connection = mockReq.socket;
+    return mockReq;
+}
+function createMockServerResponse() {
+    const mockRes = new ServerResponse({});
+    return mockRes;
+}
+const createServer = async (appContext, ssgRoutes, pageRoutes, apiRoutes, options)=>{
+    const entries = ssgRoutes.map((route)=>route.entryName);
+    const backup = openRouteSSR(pageRoutes, entries);
+    const total = backup.concat(apiRoutes);
+    try {
+        const meta = getMeta(appContext.metaName);
+        const distDirectory = appContext.distDirectory;
+        const serverConfigPath = path.resolve(distDirectory, SERVER_DIR, `${meta}.server`);
+        const plugins = appContext.serverPlugins;
+        const serverOptions = {
+            pwd: distDirectory,
+            config: options,
+            appContext,
+            serverConfigPath,
+            routes: total,
+            plugins: await loadServerPlugins(plugins, appContext.appDirectory || distDirectory),
+            staticGenerate: true,
+            logger: getLogger()
+        };
+        const nodeServer = await createProdServer(serverOptions);
+        const requestHandler = nodeServer.getRequestHandler();
+        const chunkedRoutes = chunkArray(ssgRoutes, MAX_CONCURRENT_REQUESTS);
+        const results = [];
+        for (const routes of chunkedRoutes){
+            const promises = routes.map(async (route)=>{
+                const url = `http://localhost${route.urlPath}`;
+                const request = new Request(url, {
+                    method: 'GET',
+                    headers: {
+                        host: 'localhost',
+                        'x-modern-ssg-render': 'true'
+                    }
+                });
+                const mockReq = createMockIncomingMessage(url);
+                const mockRes = createMockServerResponse();
+                const response = await requestHandler(request, {
+                    node: {
+                        req: mockReq,
+                        res: mockRes
+                    }
+                });
+                return await response.text();
+            });
+            const batch = await Promise.all(promises);
+            results.push(...batch);
+        }
+        return results;
+    } catch (e) {
+        logger.error(e instanceof Error ? e.stack : e.toString());
+        throw new Error('ssg render failed');
+    }
+};
+export { createServer };

package/dist/esm/server/prerender.mjs

@@ -0,0 +1,30 @@
+import events from "events";
+import { Readable } from "stream";
+import node_mocks_http from "node-mocks-http";
+const compile = (requestHandler)=>(options, extend = {})=>new Promise((resolve, reject)=>{
+            const req = node_mocks_http.createRequest({
+                ...options,
+                eventEmitter: Readable
+            });
+            const res = node_mocks_http.createResponse({
+                eventEmitter: events
+            });
+            Object.assign(req, extend);
+            const proxyRes = new Proxy(res, {
+                get (obj, prop) {
+                    if ('symbol' == typeof prop && !obj[prop]) return null;
+                    return obj[prop];
+                }
+            });
+            res.on('finish', ()=>{
+                if (200 !== res.statusCode) reject(new Error(res.statusMessage));
+                else resolve(res._getData());
+            });
+            res.on('error', (e)=>reject(e));
+            try {
+                requestHandler(req, proxyRes);
+            } catch (e) {
+                reject(e);
+            }
+        });
+export { compile };

package/dist/esm-node/index.mjs

@@ -0,0 +1,89 @@
+import path from "path";
+import { filterRoutesForServer, logger } from "@modern-js/utils";
+import { makeRoute } from "./libs/make.mjs";
+import { writeHtmlFile } from "./libs/output.mjs";
+import { replaceRoute } from "./libs/replace.mjs";
+import { flattenRoutes, formatOutput, isDynamicUrl, readJSONSpec, standardOptions, writeJSONSpec } from "./libs/util.mjs";
+import { createServer } from "./server/index.mjs";
+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 = flattenRoutes(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 = path.join(appDirectory, outputPath);
+                const routes = readJSONSpec(buildDir);
+                const pageRoutes = routes.filter((route)=>route.isSPA);
+                const apiRoutes = routes.filter((route)=>!route.isSPA);
+                if (0 === pageRoutes.length) return;
+                const intermediateOptions = 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(makeRoute(pageRoute, route, headers));
+                        });
+                        else agreedRoutes.forEach((route)=>{
+                            if (!isDynamicUrl(route.path)) ssgRoutes.push(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(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} `);
+                        logger.warn(`new ssg route ${ssgRoute.urlPath} is using ssr now，maybe from parent route ${ssgRoute.entryName}，close ssr`);
+                    }
+                    ssgRoute.isSSR = false;
+                    ssgRoute.output = formatOutput(ssgRoute.output);
+                });
+                const htmlAry = await createServer(appContext, ssgRoutes, pageRoutes, apiRoutes, resolvedConfig);
+                writeHtmlFile(htmlAry, ssgRoutes, buildDir);
+                replaceRoute(ssgRoutes, pageRoutes);
+                writeJSONSpec(buildDir, pageRoutes.concat(apiRoutes));
+                logger.info('ssg Compiled successfully');
+            });
+        }
+    });
+const src = ssgPlugin;
+export { src as default, ssgPlugin };

package/dist/esm-node/libs/make.mjs

@@ -0,0 +1,31 @@
+import path from "path";
+import normalize_path from "normalize-path";
+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: normalize_path(`${urlPath}${route}`) || '/',
+        headers,
+        output: path.join(entryPath, `..${'/' === route ? '' : route}`)
+    };
+    return {
+        ...baseRoute,
+        urlPath: normalize_path(`${urlPath}${route.url}`) || '/',
+        headers: {
+            ...headers,
+            ...route.headers
+        },
+        output: route.output ? path.normalize(route.output) : path.join(entryPath, `..${'/' === route.url ? '' : route.url}`)
+    };
+}
+export { makeRender, makeRoute };

package/dist/esm-node/libs/output.mjs

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

@@ -0,0 +1,28 @@
+import normalize_path from "normalize-path";
+function exist(route, pageRoutes) {
+    return pageRoutes.slice().findIndex((pageRoute)=>{
+        const urlEqual = normalize_path(pageRoute.urlPath) === normalize_path(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;
+}
+export { exist, replaceRoute };

package/dist/esm-node/libs/util.mjs

@@ -0,0 +1,147 @@
+import path_0 from "path";
+import { ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, fs, isSingleEntry } from "@modern-js/utils";
+function formatOutput(filename) {
+    const outputPath = path_0.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 = path_0.join(dir, ROUTE_SPEC_FILE);
+    const routeJSON = require(routeJSONPath);
+    const { routes } = routeJSON;
+    return routes;
+};
+const writeJSONSpec = (dir, routes)=>{
+    const routeJSONPath = path_0.join(dir, ROUTE_SPEC_FILE);
+    fs.writeJSONSync(routeJSONPath, {
+        routes
+    }, {
+        spaces: 2
+    });
+};
+const replaceWithAlias = (base, filePath, alias)=>path_0.posix.join(alias, path_0.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 = 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: `${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;
+}
+export { chunkArray, flattenRoutes, formatOutput, formatPath, getOutput, getUrlPrefix, isDynamicUrl, openRouteSSR, readJSONSpec, replaceWithAlias, standardOptions, writeJSONSpec };

package/dist/esm-node/server/consts.mjs

@@ -0,0 +1,2 @@
+const CLOSE_SIGN = 'modern_close_server';
+export { CLOSE_SIGN };