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

package/dist/esm-node/index.mjs

@@ -0,0 +1,91 @@
+import "node:module";
+import { filterRoutesForServer, logger } from "@modern-js/utils";
+import path from "path";
+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 default src;
+export { ssgPlugin };

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

@@ -0,0 +1,32 @@
+import "node:module";
+import normalize_path from "normalize-path";
+import path from "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,12 @@
+import "node:module";
+import { fs } from "@modern-js/utils";
+import path from "path";
+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,29 @@
+import "node:module";
+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,149 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, fs, isSingleEntry } from "@modern-js/utils";
+import path_0 from "path";
+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,3 @@
+import "node:module";
+const CLOSE_SIGN = 'modern_close_server';
+export { CLOSE_SIGN };

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

@@ -0,0 +1,98 @@
+import "node:module";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { createProdServer, loadServerPlugins } from "@modern-js/prod-server";
+import { SERVER_DIR, createLogger, getMeta, logger } from "@modern-js/utils";
+import path from "path";
+import { chunkArray, openRouteSSR } from "../libs/util.mjs";
+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-node/server/prerender.mjs

@@ -0,0 +1,31 @@
+import "node:module";
+import events from "events";
+import node_mocks_http from "node-mocks-http";
+import { Readable } from "stream";
+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 || 'Prerender failed'));
+                else resolve(res._getData());
+            });
+            res.on('error', (e)=>reject(e));
+            try {
+                requestHandler(req, proxyRes);
+            } catch (e) {
+                reject(e);
+            }
+        });
+export { compile };

package/dist/esm-node/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+export declare const ssgPlugin: () => CliPlugin<AppTools>;
+export default ssgPlugin;

package/dist/types/libs/make.d.ts

@@ -0,0 +1,5 @@
+import type { ServerRoute as ModernRoute } from '@modern-js/types';
+import type { compile } from '../server/prerender';
+import type { SSGRouteOptions, SsgRoute } from '../types';
+export declare function makeRender(ssgRoutes: SsgRoute[], render: ReturnType<typeof compile>, port: number): Promise<string>[];
+export declare function makeRoute(baseRoute: ModernRoute, route: string | SSGRouteOptions, headers?: Record<string, any>): SsgRoute;

package/dist/types/libs/output.d.ts

@@ -0,0 +1,2 @@
+import type { SsgRoute } from '../types';
+export declare function writeHtmlFile(htmlAry: string[], ssgRoutes: SsgRoute[], baseDir: string): void;

package/dist/types/libs/replace.d.ts

@@ -0,0 +1,4 @@
+import type { ServerRoute as ModernRoute } from '@modern-js/types';
+import type { SsgRoute } from '../types';
+export declare function exist(route: ModernRoute, pageRoutes: ModernRoute[]): number;
+export declare function replaceRoute(ssgRoutes: SsgRoute[], pageRoutes: ModernRoute[]): ModernRoute[];

package/dist/types/libs/util.d.ts

@@ -0,0 +1,27 @@
+import type { ServerUserConfig } from '@modern-js/app-tools';
+import type { ServerRoute as ModernRoute } from '@modern-js/types';
+import type { AgreedRoute, EntryPoint, SSGConfig, SSGMultiEntryOptions, SsgRoute } from '../types';
+export declare function formatOutput(filename: string): string;
+export declare function formatPath(str: string): string;
+export declare function isDynamicUrl(url: string): boolean;
+export declare function getUrlPrefix(route: SsgRoute, baseUrl: string | string[]): string;
+export declare function getOutput(route: SsgRoute, base: string, agreed?: boolean): string;
+export declare const readJSONSpec: (dir: string) => ModernRoute[];
+export declare const writeJSONSpec: (dir: string, routes: ModernRoute[]) => void;
+export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => string;
+export declare const standardOptions: (ssgOptions: SSGConfig, entrypoints: EntryPoint[], routes: ModernRoute[], server: ServerUserConfig, ssgByEntries?: SSGMultiEntryOptions) => false | SSGMultiEntryOptions;
+export declare const openRouteSSR: (routes: ModernRoute[], entries?: string[]) => {
+    isSSR: boolean;
+    bundle: string;
+    entryName?: string;
+    urlPath: string;
+    entryPath: string;
+    isSPA?: boolean;
+    isRSC?: boolean;
+    isStream?: boolean;
+    isApi?: boolean;
+    worker?: string;
+    responseHeaders?: Record<string, unknown>;
+}[];
+export declare const flattenRoutes: (routes: AgreedRoute[]) => AgreedRoute[];
+export declare function chunkArray<T>(arr: T[], size: number): T[][];

package/dist/types/server/consts.d.ts

@@ -0,0 +1 @@
+export declare const CLOSE_SIGN = "modern_close_server";

package/dist/types/server/index.d.ts

@@ -0,0 +1,4 @@
+import type { AppNormalizedConfig, AppToolsContext } from '@modern-js/app-tools';
+import type { ServerRoute as ModernRoute } from '@modern-js/types';
+import type { SsgRoute } from '../types';
+export declare const createServer: (appContext: AppToolsContext, ssgRoutes: SsgRoute[], pageRoutes: ModernRoute[], apiRoutes: ModernRoute[], options: AppNormalizedConfig) => Promise<string[]>;

package/dist/types/server/prerender.d.ts

@@ -0,0 +1,10 @@
+import type { NodeRequest, NodeResponse } from '@modern-js/types';
+export type Options = {
+    url: string;
+    headers: {
+        host: string;
+        [key: string]: string;
+    };
+    [propName: string]: any;
+};
+export declare const compile: (requestHandler: (req: NodeRequest, res: NodeResponse) => void) => (options: Options, extend?: {}) => Promise<string>;

package/dist/types/types.d.ts

@@ -0,0 +1,23 @@
+import type { ServerRoute as ModernRoute, SSGConfig, SSGMultiEntryOptions, SSGRouteOptions, SSGSingleEntryOptions } from '@modern-js/types';
+export type { SSGConfig, SSGMultiEntryOptions, SSGRouteOptions, SSGSingleEntryOptions, };
+export type AgreedRoute = {
+    path?: string;
+    component?: string;
+    _component?: string;
+    children?: AgreedRoute[];
+    exact?: boolean;
+};
+export type EntryPoint = {
+    entryName: string;
+    entry: string;
+};
+export type AgreedRouteMap = {
+    [propNames: string]: AgreedRoute[];
+};
+export type SsgRoute = ModernRoute & {
+    output: string;
+    headers?: Record<string, string>;
+};
+export type ExtendOutputConfig = {
+    ssg: SSGConfig;
+};

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@bleedingdev/modern-js-plugin-ssg",
+  "description": "A Progressive React Framework for modern web development.",
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/cli/plugin-ssg"
+  },
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js"
+  ],
+  "version": "3.2.0-ultramodern.0",
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types/index.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "node": {
+        "import": "./dist/esm-node/index.mjs",
+        "require": "./dist/cjs/index.js"
+      },
+      "default": "./dist/cjs/index.js"
+    },
+    "./cli": {
+      "types": "./dist/types/index.d.ts",
+      "node": {
+        "import": "./dist/esm-node/index.mjs",
+        "require": "./dist/cjs/index.js"
+      },
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "dependencies": {
+    "@swc/helpers": "^0.5.21",
+    "node-mocks-http": "^1.17.2",
+    "normalize-path": "3.0.0",
+    "@modern-js/prod-server": "npm:@bleedingdev/modern-js-prod-server@3.2.0-ultramodern.0",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.0"
+  },
+  "peerDependencies": {
+    "react-router-dom": ">=7.12.0"
+  },
+  "peerDependenciesMeta": {
+    "react-router-dom": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@rslib/core": "0.21.5",
+    "@types/node": "^25.8.0",
+    "@typescript/native-preview": "7.0.0-dev.20260516.1",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "react-router-dom": "^7.15.1",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.2.0-ultramodern.0",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.0",
+    "@scripts/rstest-config": "2.66.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "test": "rstest --passWithNoTests"
+  }
+}

package/rslib.config.mts

@@ -0,0 +1,4 @@
+import { rslibConfig } from '@modern-js/rslib';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig(rslibConfig);

package/rstest.config.mts

@@ -0,0 +1,7 @@
+import { withTestPreset } from '@scripts/rstest-config';
+
+export default withTestPreset({
+  root: __dirname,
+  testEnvironment: 'node',
+  globals: true,
+});