@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.30 → 3.5.0-ultramodern.32

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

@@ -0,0 +1,71 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    EmptyFallback: ()=>EmptyFallback,
+    TANSTACK_RSC_FLIGHT_VALUE: ()=>TANSTACK_RSC_FLIGHT_VALUE,
+    isSerializedTanstackRscFlightValue: ()=>isSerializedTanstackRscFlightValue,
+    renderSelectedTree: ()=>renderSelectedTree,
+    selectTreePath: ()=>selectTreePath
+});
+const external_symbols_js_namespaceObject = require("./symbols.js");
+const TANSTACK_RSC_FLIGHT_VALUE = '__modernTanstackRsc';
+function isSerializedTanstackRscFlightValue(value) {
+    return Boolean(value) && 'object' == typeof value && true === value[TANSTACK_RSC_FLIGHT_VALUE] && ('renderable' === value.kind || 'composite' === value.kind) && value.stream instanceof ReadableStream;
+}
+function EmptyFallback() {
+    return null;
+}
+function selectTreePath(tree, path) {
+    let current = tree;
+    for (const key of path){
+        if (null === current || 'object' != typeof current) return null;
+        current = current[key];
+    }
+    return current;
+}
+function renderSelectedTree(src, { getTree = src[external_symbols_js_namespaceObject.RSC_PROXY_GET_TREE], missingTreeError }) {
+    if (!getTree) throw new Error(missingTreeError);
+    return selectTreePath(getTree(), src[external_symbols_js_namespaceObject.RSC_PROXY_PATH] || []);
+}
+exports.EmptyFallback = __webpack_exports__.EmptyFallback;
+exports.TANSTACK_RSC_FLIGHT_VALUE = __webpack_exports__.TANSTACK_RSC_FLIGHT_VALUE;
+exports.isSerializedTanstackRscFlightValue = __webpack_exports__.isSerializedTanstackRscFlightValue;
+exports.renderSelectedTree = __webpack_exports__.renderSelectedTree;
+exports.selectTreePath = __webpack_exports__.selectTreePath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EmptyFallback",
+    "TANSTACK_RSC_FLIGHT_VALUE",
+    "isSerializedTanstackRscFlightValue",
+    "renderSelectedTree",
+    "selectTreePath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,72 @@
+"use strict";
+"use client";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    createTreeGetterFromFlightStream: ()=>createTreeGetterFromFlightStream
+});
+const external_react_namespaceObject = require("react");
+let modernRscClientRuntimePromise;
+function loadModernRscClientRuntime() {
+    modernRscClientRuntimePromise ??= import("@modern-js/runtime/rsc/client").then((runtime)=>{
+        runtime.setServerCallback(runtime.callServer);
+        return runtime;
+    });
+    return modernRscClientRuntimePromise;
+}
+async function createFromFlightStream(stream) {
+    if ("u" < typeof window) {
+        const runtime = await import("react-server-dom-rspack/client.edge");
+        return runtime.createFromReadableStream(stream);
+    }
+    const runtime = await loadModernRscClientRuntime();
+    return runtime.createFromReadableStream(stream, {
+        callServer: runtime.callServer
+    });
+}
+function createTreeGetterFromFlightStream(stream) {
+    let ready = false;
+    let tree;
+    const treePromise = createFromFlightStream(stream).then((value)=>{
+        tree = value;
+        ready = true;
+        return value;
+    });
+    return ()=>{
+        if (ready) return tree;
+        return (0, external_react_namespaceObject.use)(treePromise);
+    };
+}
+exports.createTreeGetterFromFlightStream = __webpack_exports__.createTreeGetterFromFlightStream;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createTreeGetterFromFlightStream"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/ssrManagedTags.js

@@ -0,0 +1,103 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__);
+async function waitForRouterSerialization(tanstackRouter) {
+    const serverSsr = tanstackRouter.serverSsr;
+    if (!serverSsr || 'function' != typeof serverSsr.onSerializationFinished || serverSsr.isSerializationFinished?.()) return;
+    await new Promise((resolve)=>{
+        serverSsr.onSerializationFinished?.(resolve);
+    });
+}
+function htmlEscapeAttr(value) {
+    return value.replace(/&/g, '&').replace(/"/g, '"');
+}
+function routerManagedTagToHtml(tag) {
+    if (!tag || 'object' != typeof tag) return '';
+    const managedTag = tag;
+    if (!managedTag || "script" !== managedTag.tag) return '';
+    const attrs = managedTag.attrs || {};
+    const attrsStr = Object.entries(attrs).filter(([, v])=>null != v && false !== v).map(([k, v])=>{
+        const name = 'className' === k ? 'class' : k;
+        if (true === v) return name;
+        return `${name}="${htmlEscapeAttr(String(v))}"`;
+    }).join(' ');
+    const open = attrsStr.length ? `<script ${attrsStr}>` : "<script>";
+    const children = 'string' == typeof managedTag.children ? managedTag.children : '';
+    return `${open}${children}</script>`;
+}
+function routerManagedTagsToHtml(tags) {
+    const normalizedTags = Array.isArray(tags) ? tags : [
+        tags
+    ];
+    return normalizedTags.map(routerManagedTagToHtml).filter(Boolean);
+}
+function createGetSsrHref(request) {
+    const url = new URL(request.url);
+    return `${url.pathname}${url.search}${url.hash}`;
+}
+function collectRouterErrors(tanstackRouter) {
+    const state = tanstackRouter.state;
+    const matches = Array.isArray(state.matches) ? state.matches : [];
+    const errors = matches.reduce((acc, match)=>{
+        if (!match.error) return acc;
+        const routeId = 'string' == typeof match.routeId ? match.routeId : 'string' == typeof match.route?.id ? match.route.id : `match-${Object.keys(acc).length}`;
+        acc[routeId] = match.error;
+        return acc;
+    }, {});
+    return Object.keys(errors).length > 0 ? errors : void 0;
+}
+async function attachServerSsrUtils(router) {
+    const { attachRouterServerSsrUtils } = await import("@tanstack/router-core/ssr/server");
+    attachRouterServerSsrUtils({
+        router,
+        manifest: void 0
+    });
+}
+__webpack_require__.d(__webpack_exports__, {
+    attachServerSsrUtils: ()=>attachServerSsrUtils,
+    collectRouterErrors: ()=>collectRouterErrors,
+    createGetSsrHref: ()=>createGetSsrHref,
+    routerManagedTagsToHtml: ()=>routerManagedTagsToHtml,
+    waitForRouterSerialization: ()=>waitForRouterSerialization
+});
+exports.attachServerSsrUtils = __webpack_exports__.attachServerSsrUtils;
+exports.collectRouterErrors = __webpack_exports__.collectRouterErrors;
+exports.createGetSsrHref = __webpack_exports__.createGetSsrHref;
+exports.routerManagedTagsToHtml = __webpack_exports__.routerManagedTagsToHtml;
+exports.waitForRouterSerialization = __webpack_exports__.waitForRouterSerialization;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "attachServerSsrUtils",
+    "collectRouterErrors",
+    "createGetSsrHref",
+    "routerManagedTagsToHtml",
+    "waitForRouterSerialization"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/ssrPreload.js

@@ -0,0 +1,89 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__);
+function isPromiseLike(value) {
+    return Boolean(value && 'function' == typeof value.then);
+}
+function isPreloadableRouteComponent(component) {
+    if (!component || 'function' != typeof component) return false;
+    const preloadable = component;
+    return 'function' == typeof preloadable.load || 'function' == typeof preloadable.preload;
+}
+function isReactLazyRouteComponent(component) {
+    return null != component && 'object' == typeof component && 'function' == typeof component._init && '_payload' in component;
+}
+async function preloadReactLazyRouteComponent(component) {
+    try {
+        component._init?.(component._payload);
+    } catch (thrown) {
+        if (!isPromiseLike(thrown)) throw thrown;
+        await thrown;
+        component._init?.(component._payload);
+    }
+}
+async function preloadRouteComponent(component, preloadedComponents) {
+    if (isReactLazyRouteComponent(component)) {
+        if (preloadedComponents.has(component)) return;
+        preloadedComponents.add(component);
+        await preloadReactLazyRouteComponent(component);
+        return;
+    }
+    if (!isPreloadableRouteComponent(component)) return;
+    if (preloadedComponents.has(component)) return;
+    preloadedComponents.add(component);
+    if ('function' == typeof component.load) return void await component.load({});
+    await component.preload?.({});
+}
+async function preloadMatchedRouteComponents(tanstackRouter) {
+    const matches = Array.isArray(tanstackRouter.state.matches) ? tanstackRouter.state.matches : [];
+    const routesById = tanstackRouter.routesById || {};
+    const preloadedComponents = new Set();
+    await Promise.all(matches.map(async (match)=>{
+        const routeId = 'string' == typeof match.routeId ? match.routeId : 'string' == typeof match.route?.id ? match.route.id : void 0;
+        const route = routeId ? routesById[routeId] : match.route;
+        const options = route?.options;
+        if (!options) return;
+        await Promise.all([
+            preloadRouteComponent(options.component, preloadedComponents),
+            preloadRouteComponent(options.pendingComponent, preloadedComponents),
+            preloadRouteComponent(options.errorComponent, preloadedComponents),
+            preloadRouteComponent(options.notFoundComponent, preloadedComponents)
+        ]);
+    }));
+}
+__webpack_require__.d(__webpack_exports__, {
+    preloadMatchedRouteComponents: ()=>preloadMatchedRouteComponents
+});
+exports.preloadMatchedRouteComponents = __webpack_exports__.preloadMatchedRouteComponents;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "preloadMatchedRouteComponents"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/ssrTypes.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/submitAction.js

@@ -0,0 +1,161 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    RouteActionResponseError: ()=>RouteActionResponseError,
+    submitRouteAction: ()=>submitRouteAction
+});
+const external_formData_js_namespaceObject = require("./formData.js");
+class RouteActionResponseError extends Error {
+    constructor(response, data){
+        super(`Route action failed with status ${response.status}`);
+        this.name = 'RouteActionResponseError';
+        this.response = response;
+        this.data = data;
+    }
+}
+function resolveRouteHandlers(router, actionTo) {
+    const builtLocation = router.buildLocation({
+        to: actionTo
+    });
+    const href = router.getParsedLocationHref(builtLocation);
+    const matchedRoutes = router.getMatchedRoutes(builtLocation.pathname);
+    const routeStaticData = matchedRoutes.foundRoute?.options?.staticData;
+    const action = routeStaticData?.modernRouteAction;
+    const loader = routeStaticData?.modernRouteLoader;
+    return {
+        action,
+        loader,
+        href,
+        params: matchedRoutes.routeParams || {}
+    };
+}
+function isRedirectResponse(value) {
+    if (!(value instanceof Response)) return false;
+    return [
+        301,
+        302,
+        303,
+        307,
+        308
+    ].includes(value.status);
+}
+async function parseResponseData(response) {
+    if (204 === response.status) return null;
+    const contentType = response.headers.get('Content-Type') || '';
+    if (contentType.includes('application/json')) return response.json();
+    return response.text();
+}
+async function parseResponseResultOrThrow(response) {
+    const parsed = await parseResponseData(response);
+    if (!response.ok) throw new RouteActionResponseError(response, parsed);
+    return parsed;
+}
+async function submitRouteAction({ router, target, options = {}, isFetcher = false, onInvalidateStart }) {
+    const method = (options.method || 'post').toLowerCase();
+    const encType = options.encType || 'application/x-www-form-urlencoded';
+    const actionTo = options.action || '.';
+    const formData = (0, external_formData_js_namespaceObject.toFormData)(target);
+    const resolved = resolveRouteHandlers(router, actionTo);
+    if ('get' === method) {
+        const search = (0, external_formData_js_namespaceObject.formDataToUrlSearchParams)(formData).toString();
+        const requestUrl = new URL(resolved.href, window.location.origin);
+        requestUrl.search = search;
+        if (isFetcher && resolved.loader) {
+            const result = await resolved.loader({
+                request: new Request(requestUrl, {
+                    method: 'GET'
+                }),
+                params: resolved.params
+            });
+            if (result instanceof Response) {
+                const redirectTo = result.headers.get('X-Modernjs-Redirect') || result.headers.get('Location');
+                if (redirectTo || isRedirectResponse(result)) {
+                    await router.navigate({
+                        to: redirectTo || '/'
+                    });
+                    return parseResponseData(result);
+                }
+                return parseResponseResultOrThrow(result);
+            }
+            return result;
+        }
+        await router.navigate({
+            href: `${requestUrl.pathname}${requestUrl.search}${requestUrl.hash}`
+        });
+        return;
+    }
+    if (!resolved.action) throw new Error(`No route action found for "${actionTo}"`);
+    const headers = new Headers();
+    let body = null;
+    if (encType.includes('application/json')) {
+        headers.set('Content-Type', 'application/json');
+        body = JSON.stringify(Object.fromEntries((0, external_formData_js_namespaceObject.formDataToUrlSearchParams)(formData).entries()));
+    } else if (encType.includes('text/plain')) {
+        headers.set('Content-Type', 'text/plain;charset=UTF-8');
+        body = (0, external_formData_js_namespaceObject.formDataToTextPlain)(formData);
+    } else if (encType.includes('application/x-www-form-urlencoded')) {
+        headers.set('Content-Type', 'application/x-www-form-urlencoded;charset=UTF-8');
+        body = (0, external_formData_js_namespaceObject.formDataToUrlSearchParams)(formData);
+    } else body = formData;
+    const request = new Request(new URL(resolved.href, window.location.origin), {
+        method: method.toUpperCase(),
+        headers,
+        body
+    });
+    const result = await resolved.action({
+        request,
+        params: resolved.params
+    });
+    if (result instanceof Response) {
+        const redirectTo = result.headers.get('X-Modernjs-Redirect') || result.headers.get('Location');
+        if (redirectTo || isRedirectResponse(result)) {
+            await router.navigate({
+                to: redirectTo || '/'
+            });
+            return parseResponseData(result);
+        }
+        const parsed = isFetcher ? await parseResponseResultOrThrow(result) : await parseResponseData(result);
+        onInvalidateStart?.();
+        await router.invalidate();
+        return parsed;
+    }
+    onInvalidateStart?.();
+    await router.invalidate();
+    return result;
+}
+exports.RouteActionResponseError = __webpack_exports__.RouteActionResponseError;
+exports.submitRouteAction = __webpack_exports__.submitRouteAction;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RouteActionResponseError",
+    "submitRouteAction"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/utils.js

@@ -37,103 +37,66 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    createRouteObjectsFromConfig: ()=>createRouteObjectsFromConfig,
-    getRouteObjects: ()=>getRouteObjects,
-    standardSlash: ()=>standardSlash,
-    urlJoin: ()=>urlJoin
+    createTanstackRouteObjectsFromConfig: ()=>createTanstackRouteObjectsFromConfig
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
-function getRouteObjects(routes, { globalApp, ssrMode, props }) {
-    const createLayoutElement = (Component)=>{
-        const GlobalLayout = globalApp;
-        if (!GlobalLayout) return Component;
-        const LayoutWrapper = (props)=>{
-            const LayoutComponent = GlobalLayout;
-            return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(LayoutComponent, {
-                Component: Component,
-                ...props
-            });
-        };
-        return LayoutWrapper;
+function withGlobalLayout(Component, globalApp) {
+    if (!globalApp) return Component;
+    const GlobalLayout = globalApp;
+    return function(props) {
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(GlobalLayout, {
+            Component: Component,
+            ...props
+        });
     };
-    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,
-            shouldRevalidate: route.shouldRevalidate,
-            handle: {
-                ...route.handle,
-                ...'object' == typeof route.config ? route.config?.handle : {}
-            },
-            index: route.index,
-            hasLoader: Boolean(route.loader),
-            hasClientLoader: Boolean(route.clientData),
-            hasAction: Boolean(route.action),
-            ...route.isClientComponent ? {
-                isClientComponent: true
-            } : {},
-            ...route.inValidSSRRoute ? {
-                inValidSSRRoute: true
-            } : {},
-            lazyImport: route.lazyImport,
-            Component: route.component ? route.component : void 0,
-            errorElement: route.error ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.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__*/ external_react_default().createElement(LayoutComponent)
-        };
-        routeObjects.push(routeObject);
-    }
-    return routeObjects;
 }
-function createRouteObjectsFromConfig({ routesConfig, props, ssrMode }) {
+function getRouteHandle(route) {
+    return {
+        ...route.handle,
+        ...'object' == typeof route.config ? route.config?.handle : {}
+    };
+}
+function toTanstackRouteObject(route, globalApp) {
+    if ('nested' === route.type) return {
+        path: route.path,
+        id: route.id,
+        loader: route.loader,
+        action: route.action,
+        shouldRevalidate: route.shouldRevalidate,
+        handle: getRouteHandle(route),
+        index: route.index,
+        hasLoader: route.hasLoader || Boolean(route.loader),
+        hasClientLoader: route.hasClientLoader || Boolean(route.clientData),
+        hasAction: route.hasAction || Boolean(route.action),
+        ...route.isClientComponent ? {
+            isClientComponent: true
+        } : {},
+        ...route.inValidSSRRoute ? {
+            inValidSSRRoute: true
+        } : {},
+        lazyImport: route.lazyImport,
+        Component: route.component ? route.component : void 0,
+        errorElement: route.error ? /*#__PURE__*/ external_react_default().createElement(route.error) : void 0,
+        children: route.children ? route.children.map((child)=>toTanstackRouteObject(child, globalApp)).filter((child)=>null !== child) : void 0
+    };
+    if ('function' != typeof route.component && 'object' != typeof route.component) return null;
+    const LayoutComponent = withGlobalLayout(route.component, globalApp);
+    return {
+        path: route.path,
+        element: /*#__PURE__*/ external_react_default().createElement(LayoutComponent)
+    };
+}
+function createTanstackRouteObjectsFromConfig({ routesConfig }) {
     if (!routesConfig) return null;
     const { routes, globalApp } = routesConfig;
     if (!routes) return null;
-    return getRouteObjects(routes, {
-        globalApp,
-        ssrMode,
-        props
-    });
-}
-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;
+    return routes.map((route)=>toTanstackRouteObject(route, globalApp)).filter((route)=>null !== route);
 }
-exports.createRouteObjectsFromConfig = __webpack_exports__.createRouteObjectsFromConfig;
-exports.getRouteObjects = __webpack_exports__.getRouteObjects;
-exports.standardSlash = __webpack_exports__.standardSlash;
-exports.urlJoin = __webpack_exports__.urlJoin;
+exports.createTanstackRouteObjectsFromConfig = __webpack_exports__.createTanstackRouteObjectsFromConfig;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createRouteObjectsFromConfig",
-    "getRouteObjects",
-    "standardSlash",
-    "urlJoin"
+    "createTanstackRouteObjectsFromConfig"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true