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

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

@@ -0,0 +1,53 @@
+"use client";
+import { createSerializationAdapter } from "@tanstack/react-router";
+import { use } from "react";
+import { createRscProxy } from "./createRscProxy.mjs";
+let modernRscClientRuntimePromise;
+function loadModernRscClientRuntime() {
+    modernRscClientRuntimePromise ??= import("@modern-js/runtime/rsc/client").then((runtime)=>{
+        runtime.setServerCallback(runtime.callServer);
+        return runtime;
+    });
+    return modernRscClientRuntimePromise;
+}
+function createTreeGetter(stream) {
+    let ready = false;
+    let tree;
+    const treePromise = loadModernRscClientRuntime().then((runtime)=>runtime.createFromReadableStream(stream, {
+            callServer: runtime.callServer
+        })).then((value)=>{
+        tree = value;
+        ready = true;
+        return value;
+    });
+    return ()=>{
+        if (ready) return tree;
+        return use(treePromise);
+    };
+}
+function createFromFlightStream(serialized) {
+    const streamWrapper = {
+        createReplayStream: ()=>serialized.stream
+    };
+    return createRscProxy(createTreeGetter(serialized.stream), {
+        renderable: 'renderable' === serialized.kind,
+        slotUsagesStream: serialized.slotUsagesStream,
+        stream: streamWrapper
+    });
+}
+const adapter = createSerializationAdapter({
+    key: '$MODERN_TANSTACK_RSC',
+    test: (_value)=>false,
+    toSerializable: ()=>{
+        throw new Error('TanStack RSC data cannot be serialized on client.');
+    },
+    fromSerializable: (value)=>createFromFlightStream(value)
+});
+function getTanstackRscSerializationAdapters() {
+    return [
+        adapter
+    ];
+}
+const rscSerializationAdapter = getTanstackRscSerializationAdapters;
+export { CompositeComponent } from "./CompositeComponent.mjs";
+export { getTanstackRscSerializationAdapters, rscSerializationAdapter };

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

@@ -0,0 +1,107 @@
+"use client";
+import { createElement } from "react";
+import { RscNodeRenderer } from "./RscNodeRenderer.mjs";
+import { RENDERABLE_RSC, RSC_PROXY_GET_TREE, RSC_PROXY_PATH, RSC_SLOT_USAGES, RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM } from "./symbols.mjs";
+const UNHANDLED = Symbol('modern.tanstack.rsc.unhandled');
+function handleProxyTrap(kind, prop, options) {
+    switch(prop){
+        case '__SEROVAL_STREAM__':
+        case '__SEROVAL_SEQUENCE__':
+        case Symbol.iterator:
+        case Symbol.asyncIterator:
+            return 'get' === kind ? void 0 : false;
+        case SERVER_COMPONENT_STREAM:
+            return 'get' === kind ? options.stream : Boolean(options.stream);
+        case RENDERABLE_RSC:
+            return 'get' === kind ? options.renderable : true;
+        case RSC_PROXY_GET_TREE:
+            return 'get' === kind ? options.getTree : true;
+        case RSC_PROXY_PATH:
+            return 'get' === kind ? options.path : true;
+        case RSC_SLOT_USAGES_STREAM:
+            return 'get' === kind ? options.slotUsagesStream : Boolean(options.slotUsagesStream);
+        case RSC_SLOT_USAGES:
+            return 'get' === kind ? options.slotUsages : Boolean(options.slotUsages);
+        case 'then':
+            return 'get' === kind ? void 0 : UNHANDLED;
+        case 'toString':
+            return 'get' === kind ? Object.prototype.toString : UNHANDLED;
+        case 'valueOf':
+            return 'get' === kind ? Object.prototype.valueOf : UNHANDLED;
+        case 'constructor':
+            return 'get' === kind ? Object : UNHANDLED;
+        default:
+            return UNHANDLED;
+    }
+}
+function createRscProxyInternal(options) {
+    const childCache = new Map();
+    const dataProxy = options.renderable ? createRscProxyInternal({
+        ...options,
+        renderable: false
+    }) : void 0;
+    const target = options.renderable ? /*#__PURE__*/ createElement(RscNodeRenderer, {
+        data: dataProxy
+    }) : {};
+    const getChild = (key)=>{
+        if (!childCache.has(key)) childCache.set(key, createRscProxyInternal({
+            ...options,
+            path: [
+                ...options.path,
+                key
+            ]
+        }));
+        return childCache.get(key);
+    };
+    return new Proxy(target, {
+        get (proxyTarget, prop) {
+            const handled = handleProxyTrap('get', prop, options);
+            if (handled !== UNHANDLED) return handled;
+            if (options.renderable) {
+                if ('props' === prop) return proxyTarget.props;
+                if ('data' === prop) return dataProxy;
+                if (prop in proxyTarget) return proxyTarget[prop];
+            }
+            if ('symbol' == typeof prop) return;
+            return getChild(prop);
+        },
+        getOwnPropertyDescriptor (proxyTarget, prop) {
+            return options.renderable ? Object.getOwnPropertyDescriptor(proxyTarget, prop) : void 0;
+        },
+        getPrototypeOf (proxyTarget) {
+            return options.renderable ? Object.getPrototypeOf(proxyTarget) : Object.prototype;
+        },
+        has (proxyTarget, prop) {
+            const handled = handleProxyTrap('has', prop, options);
+            if (handled !== UNHANDLED) return Boolean(handled);
+            if (options.renderable) return prop in proxyTarget || 'string' == typeof prop;
+            return 'string' == typeof prop;
+        },
+        ownKeys (proxyTarget) {
+            return options.renderable ? Reflect.ownKeys(proxyTarget) : [];
+        }
+    });
+}
+function createRscProxy(getTree, options = {}) {
+    const slotUsages = 'development' === process.env.NODE_ENV && options.slotUsagesStream ? options.slotUsages ?? [] : options.slotUsages;
+    if ('development' === process.env.NODE_ENV && options.slotUsagesStream && slotUsages) consumeSlotUsages(options.slotUsagesStream, slotUsages);
+    return createRscProxyInternal({
+        getTree,
+        path: [],
+        renderable: true === options.renderable,
+        slotUsages,
+        slotUsagesStream: options.slotUsagesStream,
+        stream: options.stream
+    });
+}
+async function consumeSlotUsages(stream, slotUsages) {
+    try {
+        const reader = stream.getReader();
+        for(;;){
+            const { value, done } = await reader.read();
+            if (done) break;
+            if (value?.slot) slotUsages.push(value);
+        }
+    } catch  {}
+}
+export { createRscProxy };

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

@@ -0,0 +1 @@
+export { CompositeComponent, getTanstackRscSerializationAdapters, rscSerializationAdapter } from "./client.mjs";

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

@@ -0,0 +1,162 @@
+import { notFound, redirect } from "@tanstack/react-router";
+const payloadFetchCache = new Map();
+let payloadDecoder;
+function getRouteId(match) {
+    const routeId = match.routeId ?? match.route?.id ?? match.id;
+    return 'string' == typeof routeId ? routeId : void 0;
+}
+function getRouteStaticData(match) {
+    return match.route?.options?.staticData || {};
+}
+function getRouteParentId(match) {
+    const parentId = match.route?.parentRoute?.id;
+    return 'string' == typeof parentId ? parentId : void 0;
+}
+function toRoutePath(match) {
+    const path = match.route?.options?.path;
+    return 'string' == typeof path ? path : void 0;
+}
+function toPayloadRoute(match) {
+    const routeId = getRouteId(match);
+    if (!routeId) return;
+    const staticData = getRouteStaticData(match);
+    const params = match.params && 'object' == typeof match.params ? match.params : {};
+    const pathname = 'string' == typeof match.pathname ? match.pathname : '';
+    return {
+        handle: staticData.modernRouteHandle,
+        hasAction: Boolean(staticData.modernRouteHasAction || staticData.modernRouteAction),
+        hasErrorBoundary: false,
+        hasLoader: Boolean(staticData.modernRouteHasLoader),
+        hasClientLoader: Boolean(staticData.modernRouteHasClientLoader),
+        id: routeId,
+        index: Boolean(match.route?.options?.index) || void 0,
+        params,
+        parentId: getRouteParentId(match),
+        path: toRoutePath(match),
+        pathname,
+        pathnameBase: 'string' == typeof match.pathnameBase ? match.pathnameBase : pathname
+    };
+}
+function createTanstackRscServerPayload(router, options = {}) {
+    const matches = Array.isArray(router.state?.matches) ? router.state.matches : [];
+    const routes = [];
+    const loaderData = {};
+    const errors = {};
+    for (const match of matches){
+        const payloadRoute = toPayloadRoute(match);
+        if (payloadRoute) {
+            routes.push(payloadRoute);
+            if ('loaderData' in match && void 0 !== match.loaderData && !(options.omitClientLoaderData && payloadRoute.hasClientLoader)) loaderData[payloadRoute.id] = match.loaderData;
+            if (void 0 !== match.error) errors[payloadRoute.id] = match.error;
+        }
+    }
+    return {
+        type: 'render',
+        actionData: null,
+        errors: Object.keys(errors).length > 0 ? errors : null,
+        loaderData,
+        location: router.state?.location,
+        routes
+    };
+}
+function handleTanstackRscRedirect(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, {
+        headers: newHeaders,
+        status
+    });
+}
+function isTanstackRscPayloadNavigationEnabled() {
+    return "u" > typeof window;
+}
+async function decodePayload(stream) {
+    if (payloadDecoder) return payloadDecoder(stream);
+    const runtime = await import("@modern-js/runtime/rsc/client");
+    return runtime.createFromReadableStream(stream);
+}
+function isServerPayload(value) {
+    return Boolean(value) && 'object' == typeof value && 'render' === value.type && Array.isArray(value.routes);
+}
+function createPayloadFetchKey(request) {
+    return request.url;
+}
+function isAbsoluteUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function fetchTanstackRscPayload(request) {
+    const headers = new Headers(request.headers);
+    headers.set('x-rsc-tree', 'true');
+    const response = await fetch(request.url, {
+        credentials: 'same-origin',
+        headers,
+        method: 'GET',
+        signal: request.signal
+    });
+    const redirectLocation = response.headers.get('X-Modernjs-Redirect');
+    if (redirectLocation) {
+        if (isAbsoluteUrl(redirectLocation)) throw redirect({
+            href: redirectLocation
+        });
+        throw redirect({
+            to: redirectLocation || '/'
+        });
+    }
+    if (404 === response.status && !response.body) throw notFound();
+    if (!response.body) throw new Error('TanStack RSC payload response body is null.');
+    const payload = await decodePayload(response.body);
+    if (!isServerPayload(payload)) throw new Error('Unexpected TanStack RSC payload type.');
+    return payload;
+}
+function loadTanstackRscPayload(request) {
+    const key = createPayloadFetchKey(request);
+    let payloadPromise = payloadFetchCache.get(key);
+    if (!payloadPromise) {
+        payloadPromise = fetchTanstackRscPayload(request).finally(()=>{
+            payloadFetchCache.delete(key);
+        });
+        payloadFetchCache.set(key, payloadPromise);
+    }
+    return payloadPromise;
+}
+function isSerializedNotFound(value) {
+    return Boolean(value) && 'object' == typeof value && true === value.isNotFound;
+}
+function toRouteErrors(payload) {
+    return payload.errors && 'object' == typeof payload.errors ? payload.errors : {};
+}
+function toRouteLoaderData(payload) {
+    return payload.loaderData && 'object' == typeof payload.loaderData ? payload.loaderData : {};
+}
+async function loadTanstackRscRouteData({ hasClientLoader, loadClientData, request, routeId }) {
+    if (hasClientLoader) return loadClientData();
+    if (!routeId) return loadClientData();
+    const payload = await loadTanstackRscPayload(request);
+    const errors = toRouteErrors(payload);
+    const routeError = errors[routeId];
+    if (void 0 !== routeError) {
+        if (isSerializedNotFound(routeError)) throw notFound({
+            ...routeError,
+            routeId
+        });
+        throw routeError;
+    }
+    const loaderData = toRouteLoaderData(payload);
+    if (routeId in loaderData) return loaderData[routeId];
+    const payloadRoute = payload.routes.find((route)=>route.id === routeId);
+    if (payloadRoute && payloadRoute.hasClientLoader) return loadClientData();
+}
+function __setTanstackRscPayloadDecoderForTests(decoder) {
+    payloadDecoder = decoder;
+    payloadFetchCache.clear();
+}
+export { __setTanstackRscPayloadDecoderForTests, createTanstackRscServerPayload, handleTanstackRscRedirect, isTanstackRscPayloadNavigationEnabled, loadTanstackRscPayload, loadTanstackRscRouteData };

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

@@ -0,0 +1,200 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import { createFromReadableStream, renderRsc } from "@modern-js/runtime/rsc/server";
+import { createSerializationAdapter } from "@tanstack/react-router";
+import { RawStream } from "@tanstack/router-core";
+import { createElement, use } from "react";
+import { ClientSlot } from "./ClientSlot.mjs";
+import { createRscProxy } from "./createRscProxy.mjs";
+import { ReplayableStream } from "./ReplayableStream.mjs";
+import { sanitizeSlotArgs } from "./slotUsageSanitizer.mjs";
+import { RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM, isRenderableServerComponent, isServerComponent } from "./symbols.mjs";
+function createTreeGetter(stream) {
+    let ready = false;
+    let tree;
+    const treePromise = Promise.resolve(createFromReadableStream(stream.createReplayStream())).then((value)=>{
+        tree = value;
+        ready = true;
+        return value;
+    });
+    return ()=>{
+        if (ready) return tree;
+        return use(treePromise);
+    };
+}
+function createSlotProxy(options) {
+    const cache = new Map();
+    return new Proxy({}, {
+        get (_target, prop) {
+            if ('then' === prop || 'string' != typeof prop) return;
+            if ('children' === prop) {
+                options?.onSlotCall?.('children', []);
+                return /*#__PURE__*/ createElement(ClientSlot, {
+                    args: [],
+                    slot: 'children'
+                });
+            }
+            if (!cache.has(prop)) cache.set(prop, (...args)=>{
+                options?.onSlotCall?.(prop, args);
+                return /*#__PURE__*/ createElement(ClientSlot, {
+                    args,
+                    slot: prop
+                });
+            });
+            return cache.get(prop);
+        }
+    });
+}
+function toReplayableFlightStream(node, handlers) {
+    const flightStream = renderRsc({
+        element: node
+    });
+    return new ReplayableStream(handlers ? wrapReadableStream(flightStream, handlers) : flightStream);
+}
+async function renderServerComponent(node) {
+    const stream = toReplayableFlightStream(/*#__PURE__*/ jsx(Fragment, {
+        children: node
+    }));
+    const streamWrapper = {
+        createReplayStream: ()=>stream.createReplayStream()
+    };
+    return createRscProxy(createTreeGetter(streamWrapper), {
+        renderable: true,
+        stream: streamWrapper
+    });
+}
+async function createCompositeComponent(component) {
+    const slotUsagesEmitter = 'development' === process.env.NODE_ENV ? createReadableStreamEmitter() : void 0;
+    const slotProxy = createSlotProxy({
+        onSlotCall: slotUsagesEmitter ? (slot, args)=>{
+            const sanitizedArgs = sanitizeSlotArgs(args);
+            slotUsagesEmitter.emit({
+                slot,
+                ...sanitizedArgs.length ? {
+                    args: sanitizedArgs
+                } : {}
+            });
+        } : void 0
+    });
+    async function ServerComponentWrapper() {
+        return component(slotProxy);
+    }
+    const flightStream = toReplayableFlightStream(/*#__PURE__*/ createElement(ServerComponentWrapper), slotUsagesEmitter ? {
+        onCancel: slotUsagesEmitter.close,
+        onDone: slotUsagesEmitter.close,
+        onError: slotUsagesEmitter.close
+    } : void 0);
+    const streamWrapper = {
+        createReplayStream: ()=>flightStream.createReplayStream()
+    };
+    return createRscProxy(createTreeGetter(streamWrapper), {
+        renderable: false,
+        slotUsagesStream: slotUsagesEmitter?.stream,
+        stream: streamWrapper
+    });
+}
+const adapter = createSerializationAdapter({
+    key: '$MODERN_TANSTACK_RSC',
+    test: isServerComponent,
+    toSerializable: (component)=>{
+        const streamWrapper = component[SERVER_COMPONENT_STREAM];
+        if (!streamWrapper) throw new Error('Cannot serialize TanStack RSC without a Flight stream.');
+        const kind = isRenderableServerComponent(component) ? 'renderable' : 'composite';
+        const slotUsagesStream = 'development' === process.env.NODE_ENV && 'composite' === kind ? component[RSC_SLOT_USAGES_STREAM] : void 0;
+        return {
+            kind,
+            stream: new RawStream(streamWrapper.createReplayStream(), {
+                hint: 'text'
+            }),
+            ...slotUsagesStream ? {
+                slotUsagesStream
+            } : {}
+        };
+    },
+    fromSerializable: ()=>{
+        throw new Error('TanStack RSC data should not be deserialized on server.');
+    }
+});
+function getTanstackRscSerializationAdapters() {
+    return [
+        adapter
+    ];
+}
+const rscSerializationAdapter = getTanstackRscSerializationAdapters;
+function createReadableStreamEmitter() {
+    let closed = false;
+    const queue = [];
+    let controller = null;
+    const stream = new ReadableStream({
+        start (ctrl) {
+            controller = ctrl;
+            for (const value of queue)ctrl.enqueue(value);
+            queue.length = 0;
+            if (closed) ctrl.close();
+        },
+        cancel () {
+            closed = true;
+            controller = null;
+            queue.length = 0;
+        }
+    });
+    const emit = (value)=>{
+        if (closed) return;
+        if (!controller) return void queue.push(value);
+        try {
+            controller.enqueue(value);
+        } catch  {}
+    };
+    const close = ()=>{
+        if (closed) return;
+        closed = true;
+        try {
+            controller?.close();
+        } catch  {}
+        controller = null;
+    };
+    return {
+        close,
+        emit,
+        stream
+    };
+}
+function wrapReadableStream(source, handlers) {
+    const reader = source.getReader();
+    let finished = false;
+    const finish = (kind)=>{
+        if (finished) return;
+        finished = true;
+        if ('cancel' === kind) handlers.onCancel?.();
+        else if ('error' === kind) handlers.onError?.();
+        else handlers.onDone?.();
+        try {
+            reader.releaseLock();
+        } catch  {}
+    };
+    return new ReadableStream({
+        async pull (controller) {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    controller.close();
+                    finish('done');
+                    return;
+                }
+                controller.enqueue(value);
+            } catch (err) {
+                try {
+                    controller.error(err);
+                } catch  {}
+                finish('error');
+            }
+        },
+        async cancel (reason) {
+            try {
+                await reader.cancel(reason);
+            } catch  {}
+            finish('cancel');
+        }
+    });
+}
+export { CompositeComponent } from "./CompositeComponent.mjs";
+export { createCompositeComponent, getTanstackRscSerializationAdapters, renderServerComponent, rscSerializationAdapter };

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

@@ -0,0 +1,31 @@
+import { isValidElement } from "react";
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_TRANSITIONAL_ELEMENT_TYPE = Symbol.for('react.transitional.element');
+function isReactElementLike(value) {
+    if (!value || 'object' != typeof value && 'function' != typeof value) return false;
+    if (isValidElement(value)) return true;
+    const type = value.$$typeof;
+    return type === REACT_ELEMENT_TYPE || type === REACT_TRANSITIONAL_ELEMENT_TYPE || type === REACT_PORTAL_TYPE;
+}
+function sanitizeSlotArg(value, seen) {
+    if (isReactElementLike(value)) return 'React element';
+    if (null == value) return value;
+    if ('string' == typeof value || 'number' == typeof value || 'boolean' == typeof value || 'bigint' == typeof value) return value;
+    if ('object' != typeof value && 'function' != typeof value) return String(value);
+    if (seen.has(value)) return '[Circular]';
+    seen.add(value);
+    if (Array.isArray(value)) return value.map((item)=>sanitizeSlotArg(item, seen));
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || null === proto) {
+        const out = {};
+        for (const [key, item] of Object.entries(value))out[key] = sanitizeSlotArg(item, seen);
+        return out;
+    }
+    return String(value);
+}
+function sanitizeSlotArgs(args) {
+    const seen = new WeakSet();
+    return args.map((arg)=>sanitizeSlotArg(arg, seen));
+}
+export { sanitizeSlotArgs };

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

@@ -0,0 +1,17 @@
+const SERVER_COMPONENT_STREAM = Symbol.for('modern.tanstack.rsc.stream');
+const RENDERABLE_RSC = Symbol.for('modern.tanstack.rsc.renderable');
+const RSC_PROXY_GET_TREE = Symbol.for('modern.tanstack.rsc.proxy.getTree');
+const RSC_PROXY_PATH = Symbol.for('modern.tanstack.rsc.proxy.path');
+const RSC_SLOT_USAGES_STREAM = Symbol.for('modern.tanstack.rsc.slotUsages.stream');
+const RSC_SLOT_USAGES = Symbol.for('modern.tanstack.rsc.slotUsages');
+function isServerComponent(value) {
+    if (null == value) return false;
+    if ('object' != typeof value && 'function' != typeof value) return false;
+    return SERVER_COMPONENT_STREAM in value && void 0 !== value[SERVER_COMPONENT_STREAM];
+}
+function isRenderableServerComponent(value) {
+    if (null == value) return false;
+    if ('object' != typeof value && 'function' != typeof value) return false;
+    return RENDERABLE_RSC in value && true === value[RENDERABLE_RSC];
+}
+export { RENDERABLE_RSC, RSC_PROXY_GET_TREE, RSC_PROXY_PATH, RSC_SLOT_USAGES, RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM, isRenderableServerComponent, isServerComponent };

package/dist/esm/runtime/utils.mjs

@@ -0,0 +1,89 @@
+import { jsx } from "react/jsx-runtime";
+import react from "react";
+import { DefaultNotFound } from "./DefaultNotFound.mjs";
+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,
+            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__*/ 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
+    });
+}
+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;
+}
+export { createRouteObjectsFromConfig, getRouteObjects, standardSlash, urlJoin };

package/dist/esm/runtime.mjs

@@ -0,0 +1 @@
+export * from "./runtime/index.mjs";