@modern-js/runtime 2.69.7 → 3.0.0-alpha.1

package/dist/esm/router/runtime/rsc-router.mjs

@@ -0,0 +1,233 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import { ElementsContext, createFromReadableStream } from "@modern-js/render/client";
+import { StaticRouterProvider, createBrowserRouter, createStaticRouter, redirect } from "@modern-js/runtime-utils/router";
+import react from "react";
+const safeUse = (promise)=>{
+    if ('function' == typeof react.use) return react.use(promise);
+    return null;
+};
+const createServerPayload = (routerContext, routes)=>({
+        type: 'render',
+        actionData: routerContext.actionData,
+        errors: routerContext.errors,
+        loaderData: routerContext.loaderData,
+        location: routerContext.location,
+        routes: routerContext.matches.map((match, index, matches)=>{
+            const element = match.route.element;
+            const parentMatch = index > 0 ? matches[index - 1] : void 0;
+            let processedElement;
+            if (element) {
+                const ElementComponent = element.type;
+                processedElement = /*#__PURE__*/ react.createElement(ElementComponent, {
+                    loaderData: routerContext?.loaderData?.[match.route.id],
+                    actionData: routerContext?.actionData?.[match.route.id],
+                    params: match.params,
+                    matches: routerContext.matches.map((m)=>{
+                        const { route, pathname, params } = m;
+                        return {
+                            id: route.id,
+                            pathname,
+                            params,
+                            data: routerContext?.loaderData?.[route.id],
+                            handle: route.handle
+                        };
+                    })
+                });
+            }
+            return {
+                element: processedElement,
+                errorElement: match.route.errorElement,
+                handle: match.route.handle,
+                hasAction: !!match.route.action,
+                hasErrorBoundary: !!match.route.hasErrorBoundary,
+                hasLoader: !!match.route.loader,
+                hasClientLoader: !!match.route.hasClientLoader,
+                id: match.route.id,
+                index: match.route.index,
+                params: match.params,
+                parentId: parentMatch?.route.id || match.route.parentId,
+                path: match.route.path,
+                pathname: match.pathname,
+                pathnameBase: match.pathnameBase
+            };
+        })
+    });
+const handleRSCRedirect = (headers, basename, status)=>{
+    const newHeaders = new Headers(headers);
+    let redirectUrl = headers.get('Location');
+    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '');
+    newHeaders.set('X-Modernjs-Redirect', redirectUrl);
+    newHeaders.set('X-Modernjs-BaseUrl', basename);
+    newHeaders.delete('Location');
+    return new Response(null, {
+        status: status,
+        headers: newHeaders
+    });
+};
+const prepareRSCRoutes = async (routes)=>{
+    const isLazyComponent = (component)=>component && 'object' == typeof component && void 0 !== component._init && void 0 !== component._payload;
+    const processRoutes = async (routesList)=>{
+        await Promise.all(routesList.map(async (route)=>{
+            if ('lazyImport' in route && isLazyComponent(route.component)) route.component = (await route.lazyImport()).default;
+            if (route.children && Array.isArray(route.children)) await processRoutes(route.children);
+        }));
+    };
+    await processRoutes(routes);
+};
+const mergeRoutes = (routes, originalRoutes)=>{
+    if (!originalRoutes || !Array.isArray(originalRoutes)) return routes;
+    const routesMap = new Map();
+    const buildRoutesMap = (routesList)=>{
+        routesList.forEach((route)=>{
+            if (route.id) routesMap.set(route.id, route);
+            if ('children' in route && route.children && Array.isArray(route.children)) buildRoutesMap(route.children);
+        });
+    };
+    buildRoutesMap(routes);
+    const mergeRoutesRecursive = (origRoutes)=>origRoutes.map((origRoute)=>{
+            if (origRoute.id && routesMap.has(origRoute.id)) {
+                const matchedRoute = routesMap.get(origRoute.id);
+                const result = {
+                    loader: origRoute.hasClientLoader ? origRoute.loader : void 0,
+                    ...matchedRoute
+                };
+                if (origRoute.children && Array.isArray(origRoute.children)) result.children = mergeRoutesRecursive(origRoute.children);
+                return result;
+            }
+            return origRoute;
+        });
+    return mergeRoutesRecursive(originalRoutes);
+};
+const findRouteInTree = (routes, routeId)=>{
+    for (const route of routes){
+        if (route.id === routeId) return route;
+        if (route.children && Array.isArray(route.children)) {
+            const found = findRouteInTree(route.children, routeId);
+            if (found) return found;
+        }
+    }
+    return null;
+};
+const createClientRouterFromPayload = (payload, originalRoutes, basename = '')=>{
+    const processedRoutes = payload.routes.reduceRight((previous, route)=>{
+        if (previous.length > 0) return [
+            {
+                ...route,
+                children: previous
+            }
+        ];
+        return [
+            route
+        ];
+    }, []);
+    const mergedRoutes = mergeRoutes(processedRoutes, originalRoutes);
+    const router = createBrowserRouter(mergedRoutes, {
+        hydrationData: payload,
+        basename: basename,
+        dataStrategy: async (context)=>{
+            const { request, matches } = context;
+            const results = {};
+            const clientMatches = matches.filter((match)=>match.route.hasClientLoader);
+            const fetchPromise = fetch(request.url, {
+                headers: {
+                    'x-rsc-tree': 'true'
+                }
+            });
+            const clientLoadersPromise = clientMatches.length > 0 ? Promise.all(clientMatches.map(async (clientMatch)=>{
+                const foundRoute = findRouteInTree(originalRoutes, clientMatch.route.id);
+                clientMatch.route.loader = foundRoute?.loader;
+                const res = await clientMatch.resolve();
+                return {
+                    routeId: clientMatch.route.id,
+                    result: res
+                };
+            })) : Promise.resolve([]);
+            const res = await fetchPromise;
+            const redirectLocation = res.headers.get('X-Modernjs-Redirect');
+            if (redirectLocation) {
+                matches.forEach((match)=>{
+                    const routeId = match.route.id;
+                    if (routeId) results[routeId] = {
+                        type: 'redirect',
+                        result: redirect(redirectLocation)
+                    };
+                });
+                return results;
+            }
+            const [clientLoaderResults] = await Promise.all([
+                clientLoadersPromise
+            ]);
+            clientLoaderResults.forEach(({ routeId, result })=>{
+                results[routeId] = result;
+            });
+            const payload = await createFromReadableStream(res.body);
+            if (void 0 === payload.type || 'render' !== payload.type) throw new Error('Unexpected payload type');
+            matches.forEach((match)=>{
+                const routeId = match.route.id;
+                const matchedRoute = payload.routes.find((route)=>route.id === routeId);
+                if (matchedRoute) router.patchRoutes(matchedRoute.parentId, [
+                    matchedRoute
+                ], true);
+                if (payload.loaderData?.[routeId]) results[routeId] = {
+                    type: 'data',
+                    result: payload.loaderData[routeId]
+                };
+            });
+            return results;
+        }
+    });
+    return router;
+};
+const createRSCStaticRouterComponent = (payload, basename)=>{
+    const routerContext = {
+        actionData: payload.actionData,
+        actionHeaders: {},
+        activeDeferreds: {},
+        basename: basename || '',
+        errors: payload.errors,
+        loaderData: payload.loaderData,
+        loaderHeaders: {},
+        location: payload.location,
+        statusCode: 200,
+        matches: payload.routes.map((match)=>({
+                params: match.params,
+                pathname: match.pathname,
+                pathnameBase: match.pathnameBase,
+                route: {
+                    id: match.id,
+                    action: match.hasAction || !!match.clientAction,
+                    handle: match.handle,
+                    hasErrorBoundary: match.hasErrorBoundary,
+                    loader: match.hasLoader || !!match.clientLoader,
+                    index: match.index,
+                    path: match.path,
+                    shouldRevalidate: match.shouldRevalidate
+                }
+            }))
+    };
+    const processedRoutes = payload.routes.reduceRight((previous, route)=>{
+        if (previous.length > 0) return [
+            {
+                ...route,
+                children: previous
+            }
+        ];
+        return [
+            route
+        ];
+    }, []);
+    const router = createStaticRouter(processedRoutes, routerContext);
+    return /*#__PURE__*/ jsx(StaticRouterProvider, {
+        context: routerContext,
+        router: router,
+        hydrate: false
+    });
+};
+const RSCStaticRouter = ({ basename })=>{
+    const payload = safeUse(safeUse(ElementsContext));
+    if (!payload || 'render' !== payload.type) return null;
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: createRSCStaticRouterComponent(payload, basename)
+    });
+};
+export { RSCStaticRouter, createClientRouterFromPayload, createServerPayload, handleRSCRedirect, prepareRSCRoutes };

package/dist/esm/router/runtime/rsc.mjs

@@ -0,0 +1 @@
+export * from "@modern-js/runtime-utils/router/rsc";

package/dist/esm/router/runtime/server.mjs

@@ -0,0 +1 @@
+export * from "@modern-js/runtime-utils/router";

package/dist/esm/router/runtime/utils.mjs

@@ -0,0 +1,165 @@
+import { jsx } from "react/jsx-runtime";
+import { renderNestedRoute } from "@modern-js/runtime-utils/browser";
+import { Route, UNSAFE_ErrorResponseImpl, isRouteErrorResponse } from "@modern-js/runtime-utils/router";
+import react from "react";
+import { DefaultNotFound } from "./DefaultNotFound";
+import DeferredDataScripts from "./DeferredDataScripts";
+function getRouteComponents(routes, { globalApp, ssrMode, props }) {
+    const Layout = ({ Component, ...props })=>{
+        const GlobalLayout = globalApp;
+        if (!GlobalLayout) return /*#__PURE__*/ jsx(Component, {
+            ...props
+        });
+        return /*#__PURE__*/ jsx(GlobalLayout, {
+            Component: Component,
+            ...props
+        });
+    };
+    const routeElements = [];
+    for (const route of routes)if ('nested' === route.type) {
+        const routeElement = renderNestedRoute(route, {
+            DeferredDataComponent: 'stream' === ssrMode ? DeferredDataScripts : void 0,
+            props
+        });
+        routeElements.push(routeElement);
+    } else {
+        const routeElement = /*#__PURE__*/ jsx(Route, {
+            path: route.path,
+            element: /*#__PURE__*/ jsx(Layout, {
+                Component: route.component
+            })
+        }, route.path);
+        routeElements.push(routeElement);
+    }
+    routeElements.push(/*#__PURE__*/ jsx(Route, {
+        path: "*",
+        element: /*#__PURE__*/ jsx(DefaultNotFound, {}),
+        loader: ()=>new Response('404', {
+                status: 404
+            })
+    }, "*"));
+    return routeElements;
+}
+function getRouteObjects(routes, { globalApp, ssrMode, props }) {
+    const createLayoutElement = (Component)=>{
+        const GlobalLayout = globalApp;
+        if (!GlobalLayout) return Component;
+        const LayoutWrapper = (props)=>{
+            const LayoutComponent = GlobalLayout;
+            return /*#__PURE__*/ jsx(LayoutComponent, {
+                Component: Component,
+                ...props
+            });
+        };
+        return LayoutWrapper;
+    };
+    const routeObjects = [];
+    for (const route of routes)if ('nested' === route.type) {
+        const nestedRouteObject = {
+            path: route.path,
+            id: route.id,
+            loader: route.loader,
+            action: route.action,
+            hasErrorBoundary: route.hasErrorBoundary,
+            shouldRevalidate: route.shouldRevalidate,
+            handle: {
+                ...route.handle,
+                ...'object' == typeof route.config ? route.config?.handle : {}
+            },
+            index: route.index,
+            hasClientLoader: !!route.clientData,
+            Component: route.component ? route.component : void 0,
+            errorElement: route.error ? /*#__PURE__*/ jsx(route.error, {}) : void 0,
+            children: route.children ? route.children.map((child)=>getRouteObjects([
+                    child
+                ], {
+                    globalApp,
+                    ssrMode,
+                    props
+                })[0]) : void 0
+        };
+        routeObjects.push(nestedRouteObject);
+    } else if ('function' == typeof route.component || 'object' == typeof route.component) {
+        const LayoutComponent = createLayoutElement(route.component);
+        const routeObject = {
+            path: route.path,
+            element: /*#__PURE__*/ react.createElement(LayoutComponent)
+        };
+        routeObjects.push(routeObject);
+    }
+    routeObjects.push({
+        path: '*',
+        element: /*#__PURE__*/ jsx(DefaultNotFound, {})
+    });
+    return routeObjects;
+}
+function createRouteObjectsFromConfig({ routesConfig, props, ssrMode }) {
+    if (!routesConfig) return null;
+    const { routes, globalApp } = routesConfig;
+    if (!routes) return null;
+    return getRouteObjects(routes, {
+        globalApp,
+        ssrMode,
+        props
+    });
+}
+function renderRoutes({ routesConfig, props, ssrMode }) {
+    if (!routesConfig) return null;
+    const { routes, globalApp } = routesConfig;
+    if (!routes) return null;
+    const routeElements = getRouteComponents(routes, {
+        globalApp,
+        ssrMode,
+        props
+    });
+    return routeElements;
+}
+function getLocation(serverContext) {
+    const { pathname = '', url = '' } = serverContext?.request || {};
+    const cleanUrl = url?.replace('http://', '')?.replace('https://', '');
+    const index = (cleanUrl || '').indexOf(pathname);
+    if (-1 === index) return pathname;
+    return cleanUrl.substring(index);
+}
+const urlJoin = (...parts)=>{
+    const separator = '/';
+    const replace = new RegExp(`${separator}{1,}`, 'g');
+    return standardSlash(parts.join(separator).replace(replace, separator));
+};
+function standardSlash(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 serializeErrors(errors) {
+    if (!errors) return null;
+    const entries = Object.entries(errors);
+    const serialized = {};
+    for (const [key, val] of entries)if (isRouteErrorResponse(val)) serialized[key] = {
+        ...val,
+        __type: 'RouteErrorResponse'
+    };
+    else if (val instanceof Error) serialized[key] = {
+        message: val.message,
+        stack: val.stack,
+        __type: 'Error'
+    };
+    else serialized[key] = val;
+    return serialized;
+}
+function deserializeErrors(errors) {
+    if (!errors) return null;
+    const entries = Object.entries(errors);
+    const serialized = {};
+    for (const [key, val] of entries)if (val && 'RouteErrorResponse' === val.__type) serialized[key] = new UNSAFE_ErrorResponseImpl(val.status, val.statusText, val.data, true === val.internal);
+    else if (val && 'Error' === val.__type) {
+        const error = new Error(val.message);
+        error.stack = val.stack;
+        serialized[key] = error;
+    } else serialized[key] = val;
+    return serialized;
+}
+export { createRouteObjectsFromConfig, deserializeErrors, getLocation, getRouteComponents, getRouteObjects, renderRoutes, serializeErrors, standardSlash, urlJoin };

package/dist/esm/router/runtime/withRouter.mjs

@@ -0,0 +1,14 @@
+import { jsx } from "react/jsx-runtime";
+import { useLocation, useNavigate, useParams } from "@modern-js/runtime-utils/router";
+const withRouter = (Component)=>(props)=>{
+        const location = useLocation();
+        const params = useParams();
+        const navigate = useNavigate();
+        return /*#__PURE__*/ jsx(Component, {
+            ...props,
+            location: location,
+            params: params,
+            navigate: navigate
+        });
+    };
+export { withRouter };

package/dist/esm/rsc/client.mjs

@@ -0,0 +1,3 @@
+export * from "@modern-js/render/client";
+const isRedirectResponse = (res)=>null != res.headers.get('X-Modernjs-Redirect');
+export { isRedirectResponse };

package/dist/esm-node/cli/alias.mjs

@@ -0,0 +1,24 @@
+import path from "path";
+import { ENTRY_POINT_REGISTER_FILE_NAME } from "./constants.mjs";
+const builderPluginAlias = ({ entrypoints, internalDirectory, metaName })=>({
+        name: 'runtime:alias',
+        setup (api) {
+            api.modifyRsbuildConfig((userConfig, { mergeRsbuildConfig })=>{
+                const entrypointsAlias = {};
+                const mainEntrypointsAlias = {};
+                entrypoints.forEach((entrypoint)=>{
+                    entrypointsAlias[`@${metaName}/runtime/registry/${entrypoint.entryName}$`] = path.join(internalDirectory, entrypoint.entryName, ENTRY_POINT_REGISTER_FILE_NAME);
+                    if (entrypoint.isMainEntry) mainEntrypointsAlias[`@${metaName}/runtime/registry`] = path.join(internalDirectory, entrypoint.entryName, ENTRY_POINT_REGISTER_FILE_NAME);
+                });
+                return mergeRsbuildConfig(userConfig, {
+                    resolve: {
+                        alias: {
+                            ...entrypointsAlias,
+                            ...mainEntrypointsAlias
+                        }
+                    }
+                });
+            });
+        }
+    });
+export { builderPluginAlias };

package/dist/esm-node/cli/code.mjs

@@ -0,0 +1,119 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+import { ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_POINT_REGISTER_FILE_NAME, ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME, ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME, ENTRY_SERVER_BOOTSTRAP_FILE_NAME, INDEX_FILE_NAME, SERVER_ENTRY_POINT_FILE_NAME } from "./constants.mjs";
+import { resolveSSRMode } from "./ssr/mode.mjs";
+import { AppProxyForRSC, entryForCSRWithRSC, index, register, runtimeGlobalContext, runtimeGlobalContextForRSCClient, runtimeGlobalContextForRSCServer, runtimeRegister } from "./template.mjs";
+import { entryForCSRWithRSC as external_template_server_mjs_entryForCSRWithRSC, serverIndex } from "./template.server.mjs";
+const generateCode = async (entrypoints, appContext, config, hooks)=>{
+    const { mountId } = config.html;
+    const { enableAsyncEntry } = config.source;
+    const { runtimeConfigFile, internalDirectory, internalSrcAlias, metaName, srcDirectory, serverRoutes } = appContext;
+    await Promise.all(entrypoints.map(async (entrypoint)=>{
+        const { entryName, isAutoMount, entry, customEntry, customServerEntry, nestedRoutesEntry } = entrypoint;
+        const { plugins: runtimePlugins } = await hooks._internalRuntimePlugins.call({
+            entrypoint,
+            plugins: []
+        });
+        if (isAutoMount) {
+            const ssrMode = resolveSSRMode({
+                entry: entryName,
+                config,
+                nestedRoutesEntry
+            });
+            let indexCode = '';
+            indexCode = !ssrMode && config.server.rsc ? entryForCSRWithRSC({
+                metaName,
+                entryName,
+                mountId,
+                urlPath: serverRoutes.find((route)=>route.entryName === entryName)?.urlPath,
+                isNestedRouter: entrypoint.nestedRoutesEntry
+            }) : index({
+                srcDirectory,
+                internalSrcAlias,
+                metaName,
+                entry,
+                entryName,
+                customEntry,
+                mountId,
+                enableRsc: config.server.rsc,
+                isNestedRouter: !!entrypoint.nestedRoutesEntry
+            });
+            const indexFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_FILE_NAME}`);
+            await fs.outputFile(indexFile, indexCode, 'utf8');
+            if (enableAsyncEntry) {
+                const bootstrapFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_BOOTSTRAP_FILE_NAME}`);
+                await fs.outputFile(bootstrapFile, `import(/* webpackChunkName: "async-${entryName}" */ './${INDEX_FILE_NAME}');`, 'utf8');
+                const bootstrapServerFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_SERVER_BOOTSTRAP_FILE_NAME}`);
+                if (ssrMode) await fs.outputFile(bootstrapServerFile, `export const requestHandler = import('./${SERVER_ENTRY_POINT_FILE_NAME}').then((m) => m.requestHandler)`, 'utf8');
+            }
+            if (ssrMode) {
+                const indexServerCode = serverIndex({
+                    entry,
+                    entryName,
+                    internalSrcAlias,
+                    metaName,
+                    mode: ssrMode,
+                    customServerEntry,
+                    srcDirectory,
+                    enableRsc: config.server.rsc
+                });
+                const indexServerFile = path.resolve(internalDirectory, `./${entryName}/${SERVER_ENTRY_POINT_FILE_NAME}`);
+                await fs.outputFile(indexServerFile, indexServerCode, 'utf8');
+            } else if (config.server.rsc) {
+                const indexServerFile = path.resolve(internalDirectory, `./${entryName}/${SERVER_ENTRY_POINT_FILE_NAME}`);
+                const indexServerCode = external_template_server_mjs_entryForCSRWithRSC({
+                    entryName,
+                    metaName
+                });
+                await fs.outputFile(indexServerFile, indexServerCode, 'utf8');
+            }
+            const registerCode = register();
+            const registerFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_REGISTER_FILE_NAME}`);
+            await fs.outputFile(registerFile, registerCode, 'utf8');
+            const registerRuntimeCode = runtimeRegister({
+                entryName,
+                srcDirectory,
+                internalSrcAlias,
+                metaName,
+                runtimeConfigFile,
+                runtimePlugins
+            });
+            const registerRuntimeFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME}`);
+            await fs.outputFile(registerRuntimeFile, registerRuntimeCode, 'utf8');
+            let contextCode = '';
+            if (!config.server.rsc || entrypoint.nestedRoutesEntry) {
+                const route = serverRoutes.find((r)=>r.entryName === entryName);
+                const basename = route?.urlPath || '/';
+                contextCode = runtimeGlobalContext({
+                    entryName,
+                    srcDirectory,
+                    internalSrcAlias,
+                    metaName,
+                    entry,
+                    customEntry,
+                    basename
+                });
+            } else {
+                const AppProxyPath = path.join(internalDirectory, entryName, './AppProxy.jsx');
+                const appProxyCode = AppProxyForRSC({
+                    srcDirectory,
+                    internalSrcAlias,
+                    entry,
+                    customEntry
+                });
+                await fs.outputFile(AppProxyPath, appProxyCode);
+                contextCode = runtimeGlobalContextForRSCClient({
+                    metaName
+                });
+                const contextServerCode = runtimeGlobalContextForRSCServer({
+                    metaName
+                });
+                const contextFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.server.js`);
+                await fs.outputFile(contextFile, contextServerCode, 'utf8');
+            }
+            const contextFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.js`);
+            await fs.outputFile(contextFile, contextCode, 'utf8');
+        }
+    }));
+};
+export { generateCode };

package/dist/esm-node/cli/constants.mjs

@@ -0,0 +1,10 @@
+const APP_FILE_NAME = 'App';
+const ENTRY_POINT_FILE_NAME = 'index.jsx';
+const SERVER_ENTRY_POINT_FILE_NAME = 'index.server.jsx';
+const INDEX_FILE_NAME = 'index';
+const ENTRY_BOOTSTRAP_FILE_NAME = 'bootstrap.jsx';
+const ENTRY_SERVER_BOOTSTRAP_FILE_NAME = 'bootstrap.server.jsx';
+const ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME = 'runtime-register.js';
+const ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME = 'runtime-global-context';
+const ENTRY_POINT_REGISTER_FILE_NAME = 'register.js';
+export { APP_FILE_NAME, ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_POINT_REGISTER_FILE_NAME, ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME, ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME, ENTRY_SERVER_BOOTSTRAP_FILE_NAME, INDEX_FILE_NAME, SERVER_ENTRY_POINT_FILE_NAME };

package/dist/esm-node/cli/entry.mjs

@@ -0,0 +1,6 @@
+import path from "path";
+import { JS_EXTENSIONS, findExists } from "@modern-js/utils";
+import { APP_FILE_NAME } from "./constants.mjs";
+const hasApp = (dir)=>findExists(JS_EXTENSIONS.map((ext)=>path.resolve(dir, `${APP_FILE_NAME}${ext}`)));
+const isRuntimeEntry = (dir)=>hasApp(dir);
+export { hasApp, isRuntimeEntry };

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

@@ -0,0 +1,89 @@
+import path_0 from "path";
+import { cleanRequireCache, isReact18 as utils_isReact18 } from "@modern-js/utils";
+import { documentPlugin } from "../document/cli/index.mjs";
+import { routerPlugin } from "../router/cli/index.mjs";
+import { builderPluginAlias } from "./alias.mjs";
+import { generateCode } from "./code.mjs";
+import { ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME } from "./constants.mjs";
+import { isRuntimeEntry } from "./entry.mjs";
+import { ssrPlugin } from "./ssr/index.mjs";
+const runtimePlugin = (params)=>({
+        name: '@modern-js/runtime',
+        post: [
+            '@modern-js/plugin-ssr',
+            '@modern-js/plugin-router',
+            '@modern-js/plugin-document',
+            '@modern-js/plugin-design-token'
+        ],
+        usePlugins: params?.plugins || [
+            ssrPlugin(),
+            routerPlugin(),
+            documentPlugin()
+        ],
+        setup: (api)=>{
+            api.checkEntryPoint(({ path, entry })=>({
+                    path,
+                    entry: entry || isRuntimeEntry(path)
+                }));
+            api.modifyEntrypoints(({ entrypoints })=>{
+                const { internalDirectory } = api.getAppContext();
+                const { source: { enableAsyncEntry } } = api.getNormalizedConfig();
+                const newEntryPoints = entrypoints.map((entrypoint)=>{
+                    if (entrypoint.isAutoMount) entrypoint.internalEntry = path_0.resolve(internalDirectory, `./${entrypoint.entryName}/${enableAsyncEntry ? ENTRY_BOOTSTRAP_FILE_NAME : ENTRY_POINT_FILE_NAME}`);
+                    return entrypoint;
+                });
+                return {
+                    entrypoints: newEntryPoints
+                };
+            });
+            api.generateEntryCode(async ({ entrypoints })=>{
+                const appContext = api.getAppContext();
+                const resolvedConfig = api.getNormalizedConfig();
+                const hooks = api.getHooks();
+                await generateCode(entrypoints, appContext, resolvedConfig, hooks);
+            });
+            api.onPrepare(()=>{
+                const { builder, entrypoints, internalDirectory, metaName } = api.getAppContext();
+                builder?.addPlugins([
+                    builderPluginAlias({
+                        entrypoints,
+                        internalDirectory,
+                        metaName
+                    })
+                ]);
+            });
+            api.config(()=>{
+                const { appDirectory, metaName } = api.getAppContext();
+                const isReact18 = utils_isReact18(appDirectory);
+                process.env.IS_REACT18 = isReact18.toString();
+                return {
+                    source: {
+                        globalVars: {
+                            'process.env.IS_REACT18': process.env.IS_REACT18
+                        }
+                    },
+                    tools: {
+                        bundlerChain: (chain)=>{
+                            chain.module.rule('modern-entry').test(/\.jsx?$/).include.add(path_0.resolve(appDirectory, 'node_modules', `.${metaName}`)).end().sideEffects(true);
+                        },
+                        rspack: (_config, { appendPlugins, rspack })=>{
+                            if (!isReact18) appendPlugins([
+                                new rspack.IgnorePlugin({
+                                    resourceRegExp: /^react-dom\/client$/,
+                                    contextRegExp: /@modern-js\/runtime/
+                                })
+                            ]);
+                        }
+                    }
+                };
+            });
+            api.onBeforeRestart(()=>{
+                cleanRequireCache([
+                    require.resolve('../router/cli'),
+                    require.resolve('./ssr')
+                ]);
+            });
+        }
+    });
+const cli = runtimePlugin;
+export { cli as default, documentPlugin, isRuntimeEntry, routerPlugin, runtimePlugin, ssrPlugin };