@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

package/dist/cjs/router/runtime/rsc-router.js

@@ -0,0 +1,377 @@
+"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__, {
+    RSCStaticRouter: ()=>RSCStaticRouter,
+    createClientRouterFromPayload: ()=>createClientRouterFromPayload,
+    createServerPayload: ()=>createServerPayload,
+    handleRSCRedirect: ()=>handleRSCRedirect,
+    prepareRSCRoutes: ()=>prepareRSCRoutes
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const client_namespaceObject = require("@modern-js/render/client");
+const router_namespaceObject = require("@modern-js/runtime-utils/router");
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const external_CSSLinks_js_namespaceObject = require("./CSSLinks.js");
+const safeUse = (value)=>{
+    const reactUse = external_react_default().use;
+    if ('function' == typeof reactUse) return reactUse(value);
+    return null;
+};
+function collectCssFilesFromRoutes(matches, routes) {
+    const cssFiles = [];
+    for (const match of matches){
+        const route = findRouteInTree(routes, match.route.id);
+        if (!route) continue;
+        const component = route.Component;
+        if (component && 'function' == typeof component && 'entryCssFiles' in component) {
+            const css = component.entryCssFiles;
+            if (Array.isArray(css)) cssFiles.push(...css);
+        }
+    }
+    return Array.from(new Set(cssFiles));
+}
+const createServerPayload = (routerContext, routes)=>{
+    const cssFiles = collectCssFilesFromRoutes(routerContext.matches, routes);
+    let cssInjectionIndex = -1;
+    if (cssFiles.length > 0) {
+        for(let i = routerContext.matches.length - 1; i >= 0; i--){
+            const matchRoute = findRouteInTree(routes, routerContext.matches[i].route.id);
+            if (matchRoute && !matchRoute.isClientComponent) {
+                cssInjectionIndex = i;
+                break;
+            }
+        }
+        if (-1 === cssInjectionIndex) cssInjectionIndex = routerContext.matches.length - 1;
+    }
+    return {
+        type: 'render',
+        actionData: routerContext.actionData,
+        errors: routerContext.errors,
+        loaderData: routerContext.loaderData,
+        location: routerContext.location,
+        routes: routerContext.matches.map((match, index, matches)=>{
+            const route = match.route;
+            const element = route.element;
+            const parentMatch = index > 0 ? matches[index - 1] : void 0;
+            let processedElement;
+            if (element) {
+                const ElementComponent = element.type;
+                const elementProps = {
+                    loaderData: routerContext?.loaderData?.[route.id],
+                    actionData: routerContext?.actionData?.[route.id],
+                    params: match.params,
+                    matches: routerContext.matches.map((m)=>({
+                            id: m.route.id,
+                            pathname: m.pathname,
+                            params: m.params,
+                            data: routerContext?.loaderData?.[m.route.id],
+                            handle: m.route.handle
+                        }))
+                };
+                const routeElement = /*#__PURE__*/ external_react_default().createElement(ElementComponent, elementProps);
+                processedElement = index === cssInjectionIndex ? /*#__PURE__*/ external_react_default().createElement(external_react_default().Fragment, null, /*#__PURE__*/ external_react_default().createElement(external_CSSLinks_js_namespaceObject.CSSLinks, {
+                    cssFiles
+                }), routeElement) : routeElement;
+            }
+            return {
+                element: processedElement,
+                errorElement: route.errorElement,
+                handle: route.handle,
+                hasAction: !!route.action,
+                hasErrorBoundary: !!route.hasErrorBoundary,
+                hasLoader: !!route.loader,
+                hasClientLoader: !!route.hasClientLoader,
+                id: route.id,
+                index: route.index,
+                params: match.params,
+                parentId: parentMatch?.route.id || route.parentId,
+                path: 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)=>null != component && 'object' == typeof component && '_init' in component && '_payload' in component;
+    const processRoutes = async (routesList)=>{
+        await Promise.all(routesList.map(async (route)=>{
+            const modernRoute = route;
+            if ('lazyImport' in modernRoute && isLazyComponent(modernRoute.component)) modernRoute.component = (await modernRoute.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)=>{
+            const modernOrig = origRoute;
+            if (modernOrig.id && routesMap.has(modernOrig.id)) {
+                const matchedRoute = routesMap.get(modernOrig.id);
+                const result = {
+                    loader: modernOrig.hasClientLoader ? modernOrig.loader : void 0,
+                    ...matchedRoute
+                };
+                if (modernOrig.isClientComponent) result.isClientComponent = true;
+                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;
+};
+function getChangedMatches(matches, currentMatches) {
+    const currentById = new Map();
+    for (const m of currentMatches)if (m.route?.id) currentById.set(m.route.id, m);
+    return matches.filter((match)=>{
+        const current = currentById.get(match.route?.id);
+        return !current || JSON.stringify(current.params) !== JSON.stringify(match.params);
+    });
+}
+function canSkipRscFetch(matches, routerState) {
+    const changedMatches = getChangedMatches(matches, routerState?.matches || []);
+    return changedMatches.length > 0 && changedMatches.every((m)=>{
+        const route = m.route;
+        return route.isClientComponent && !(route.hasLoader && !route.hasClientLoader);
+    });
+}
+function injectRouteCss(routeId) {
+    if ("u" < typeof window) return;
+    const cssAssets = window._MODERNJS_ROUTE_MANIFEST?.routeAssets?.[routeId]?.referenceCssAssets;
+    if (!cssAssets) return;
+    const publicPath = window.__webpack_public_path__ || '/';
+    for (const css of cssAssets){
+        const href = css.startsWith('http') || css.startsWith('/') ? css : publicPath + css;
+        if (!document.querySelector(`link[href="${CSS.escape(href)}"]`)) {
+            const link = document.createElement('link');
+            link.rel = 'stylesheet';
+            link.href = href;
+            document.head.appendChild(link);
+        }
+    }
+}
+function ensureClientComponent(route, originalRoutes) {
+    if (route.isClientComponent && !route.Component) {
+        const origRoute = findRouteInTree(originalRoutes, route.id);
+        if (origRoute?.Component) {
+            route.Component = origRoute.Component;
+            delete route.element;
+        }
+    }
+}
+function resolveClientLoaders(matches, originalRoutes) {
+    const clientMatches = matches.filter((m)=>m.route.hasClientLoader);
+    if (0 === clientMatches.length) return Promise.resolve([]);
+    return Promise.all(clientMatches.map(async (clientMatch)=>{
+        const origRoute = findRouteInTree(originalRoutes, clientMatch.route.id);
+        clientMatch.route.loader = origRoute?.loader;
+        const result = await clientMatch.resolve();
+        return {
+            routeId: clientMatch.route.id,
+            result
+        };
+    }));
+}
+function applyLoaderResults(results, loaderResults) {
+    for (const { routeId, result } of loaderResults)results[routeId] = result;
+}
+async function resolveClientOnlyNavigation(matches, results, originalRoutes, routerState) {
+    const changedMatches = getChangedMatches(matches, routerState?.matches || []);
+    for (const match of changedMatches)ensureClientComponent(match.route, originalRoutes);
+    applyLoaderResults(results, await resolveClientLoaders(changedMatches, originalRoutes));
+    for (const match of changedMatches)if (match.route.id) injectRouteCss(match.route.id);
+    return results;
+}
+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 = (0, router_namespaceObject.createBrowserRouter)(mergedRoutes, {
+        hydrationData: payload,
+        basename: basename,
+        dataStrategy: async ({ request, matches })=>{
+            const results = {};
+            if (canSkipRscFetch(matches, router.state)) return resolveClientOnlyNavigation(matches, results, originalRoutes, router.state);
+            const fetchPromise = fetch(request.url, {
+                headers: {
+                    'x-rsc-tree': 'true'
+                }
+            });
+            const clientLoadersPromise = resolveClientLoaders(matches, originalRoutes);
+            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: 'data',
+                        result: (0, router_namespaceObject.redirect)(redirectLocation)
+                    };
+                });
+                return results;
+            }
+            applyLoaderResults(results, await clientLoadersPromise);
+            if (!res.body) throw new Error('Response body is null');
+            const payload = await (0, client_namespaceObject.createFromReadableStream)(res.body);
+            if ('object' != typeof payload || null === payload || void 0 === payload.type || 'render' !== payload.type) throw new Error('Unexpected payload type');
+            const serverPayload = payload;
+            matches.forEach((match)=>{
+                const routeId = match.route.id;
+                const matchedRoute = serverPayload.routes.find((route)=>route.id === routeId);
+                if (matchedRoute) {
+                    const modernMatch = match.route;
+                    router.patchRoutes(matchedRoute.parentId ?? null, [
+                        matchedRoute
+                    ], true);
+                    if (modernMatch.isClientComponent && modernMatch.Component) delete modernMatch.Component;
+                }
+                if (serverPayload.loaderData && routeId in serverPayload.loaderData) results[routeId] = {
+                    type: 'data',
+                    result: serverPayload.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 = (0, router_namespaceObject.createStaticRouter)(processedRoutes, routerContext);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(router_namespaceObject.StaticRouterProvider, {
+        context: routerContext,
+        router: router,
+        hydrate: false
+    });
+};
+const RSCStaticRouter = ({ basename })=>{
+    const payload = safeUse(safeUse(client_namespaceObject.ElementsContext));
+    if (!payload || 'render' !== payload.type) return null;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: createRSCStaticRouterComponent(payload, basename)
+    });
+};
+exports.RSCStaticRouter = __webpack_exports__.RSCStaticRouter;
+exports.createClientRouterFromPayload = __webpack_exports__.createClientRouterFromPayload;
+exports.createServerPayload = __webpack_exports__.createServerPayload;
+exports.handleRSCRedirect = __webpack_exports__.handleRSCRedirect;
+exports.prepareRSCRoutes = __webpack_exports__.prepareRSCRoutes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RSCStaticRouter",
+    "createClientRouterFromPayload",
+    "createServerPayload",
+    "handleRSCRedirect",
+    "prepareRSCRoutes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/runtime/rsc.js

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_modules__ = {
+    "@modern-js/runtime-utils/router/rsc" (module) {
+        module.exports = require("@modern-js/runtime-utils/router/rsc");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__);
+    var _modern_js_runtime_utils_router_rsc__rspack_import_0 = __webpack_require__("@modern-js/runtime-utils/router/rsc");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _modern_js_runtime_utils_router_rsc__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_modern_js_runtime_utils_router_rsc__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/runtime/server.js

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_modules__ = {
+    "@modern-js/runtime-utils/router" (module) {
+        module.exports = require("@modern-js/runtime-utils/router");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__);
+    var _modern_js_runtime_utils_router__rspack_import_0 = __webpack_require__("@modern-js/runtime-utils/router");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _modern_js_runtime_utils_router__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_modern_js_runtime_utils_router__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/runtime/tanstack/basepathRewrite.js

@@ -0,0 +1,62 @@
+"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__, {
+    createModernBasepathRewrite: ()=>createModernBasepathRewrite
+});
+function normalizeBasepath(basepath) {
+    if (!basepath) return '/';
+    let normalized = basepath.startsWith('/') ? basepath : `/${basepath}`;
+    if (normalized.length > 1 && normalized.endsWith('/')) normalized = normalized.slice(0, -1);
+    return normalized || '/';
+}
+function createModernBasepathRewrite(basepath, caseSensitive = false) {
+    const normalizedBasepath = normalizeBasepath(basepath);
+    if ('/' === normalizedBasepath) return;
+    const normalizedBasepathWithSlash = `${normalizedBasepath}/`;
+    const checkBasepath = caseSensitive ? normalizedBasepath : normalizedBasepath.toLowerCase();
+    const checkBasepathWithSlash = caseSensitive ? normalizedBasepathWithSlash : normalizedBasepathWithSlash.toLowerCase();
+    return {
+        input: ({ url })=>{
+            const pathname = caseSensitive ? url.pathname : url.pathname.toLowerCase();
+            if (pathname === checkBasepath) url.pathname = '/';
+            else if (pathname.startsWith(checkBasepathWithSlash)) url.pathname = url.pathname.slice(normalizedBasepath.length) || '/';
+            return url;
+        },
+        output: ({ url })=>{
+            const pathname = url.pathname || '/';
+            if ('/' === pathname) url.pathname = normalizedBasepath;
+            else url.pathname = `${normalizedBasepath}${pathname.startsWith('/') ? '' : '/'}${pathname}`;
+            return url;
+        }
+    };
+}
+exports.createModernBasepathRewrite = __webpack_exports__.createModernBasepathRewrite;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createModernBasepathRewrite"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});