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

package/dist/types/runtime/formData.d.ts

@@ -0,0 +1,23 @@
+import type React from 'react';
+export type SubmitTarget = HTMLFormElement | FormData | URLSearchParams | Record<string, string | number | boolean | null | undefined>;
+export type SubmitterElement = HTMLButtonElement | HTMLInputElement;
+export type SubmitOptions = {
+    action?: string;
+    method?: string;
+    encType?: string;
+};
+export declare function formDataToUrlSearchParams(formData: FormData): URLSearchParams;
+export declare function formDataToTextPlain(formData: FormData): string;
+export declare function toFormData(target: SubmitTarget): FormData;
+export declare function getSubmitter(event: React.FormEvent<HTMLFormElement>): HTMLButtonElement | HTMLInputElement | null;
+export declare function createFormDataFromSubmit({ form, submitter, }: {
+    form: HTMLFormElement;
+    submitter: SubmitterElement | null;
+}): FormData;
+export declare function resolveSubmitOptionsFromForm({ form, submitter, action, method, encType, }: {
+    form: HTMLFormElement;
+    submitter: SubmitterElement | null;
+    action?: string;
+    method?: string;
+    encType?: string;
+}): Required<SubmitOptions>;

package/dist/types/runtime/plugin.d.ts

@@ -1,4 +1,4 @@
-import { type TanstackRouterRuntimePlugin } from './pluginCore';
+import { type TanstackRouterRuntimePlugin } from './pluginShared';
 import { type RouterConfig } from './types';
 export declare const tanstackRouterPlugin: (userConfig?: Partial<RouterConfig>) => TanstackRouterRuntimePlugin;
 export default tanstackRouterPlugin;

package/dist/types/runtime/plugin.node.d.ts

@@ -1,4 +1,4 @@
-import { type TanstackRouterRuntimePlugin } from './pluginCore';
+import { type TanstackRouterRuntimePlugin } from './pluginShared';
 import { type RouterConfig } from './types';
 export declare const tanstackRouterPlugin: (userConfig?: Partial<RouterConfig>) => TanstackRouterRuntimePlugin;
 export default tanstackRouterPlugin;

package/dist/types/runtime/{pluginCore.d.ts → pluginShared.d.ts}

@@ -1,6 +1,8 @@
 import { type TInternalRuntimeContext } from '@modern-js/runtime/context';
+import type { RouteObject } from '@modern-js/runtime-utils/router';
 import type { RouterExtendsHooks } from './hooks';
 import type { RouterConfig } from './types';
+import { type SSRMode } from './utils';
 export type TanstackRouterRuntimeConfig = {
     plugins?: TanstackRouterRuntimePlugin[];
     router?: Partial<RouterConfig>;
@@ -20,6 +22,18 @@ export type TanstackRouterRuntimePlugin = {
     setup?: (api: TanstackRouterPluginAPI) => unknown;
     [key: string]: unknown;
 };
+export type TanstackRouteConfig = {
+    mergedConfig: RouterConfig;
+    finalRouteConfig: RouterConfig['routesConfig'];
+    hasConfiguredRoutes: boolean;
+};
 export declare function getMergedRouterConfig(api: TanstackRouterPluginAPI, userConfig: Partial<RouterConfig>): RouterConfig;
 export declare function getFinalRouteConfig(mergedConfig: RouterConfig): RouterConfig['routesConfig'];
+export declare function getTanstackRouteConfig(api: TanstackRouterPluginAPI, userConfig: Partial<RouterConfig>): TanstackRouteConfig;
+export declare function createTanstackRouteObjects({ hooks, routeConfig, ssrMode, }: {
+    hooks: RouterExtendsHooks;
+    routeConfig: TanstackRouteConfig;
+    ssrMode?: SSRMode;
+}): RouteObject[];
+export declare function joinBasename(baseUrl: string, basename: string): string;
 export {};

package/dist/types/runtime/routeTree/components.d.ts

@@ -0,0 +1,7 @@
+import type { RouteObject } from '@modern-js/runtime-utils/router';
+import { type ElementType } from 'react';
+import type { RouteTreeOptions } from './types';
+export declare function pickRouteModuleComponent(routeModule: unknown, seen?: Set<unknown>): ElementType<Record<string, unknown>> | undefined;
+export declare function toRouteComponent(routeObject: RouteObject, options?: RouteTreeOptions): unknown;
+export declare function toErrorComponent(routeObject: RouteObject): unknown;
+export declare function toPendingComponent(routeObject: RouteObject): unknown;

package/dist/types/runtime/routeTree/construction.d.ts

@@ -0,0 +1,5 @@
+import type { RouteObject } from '@modern-js/runtime-utils/router';
+import type { AnyRouter } from '@tanstack/react-router';
+import type { ModernTanstackRootRoute, RouteTreeOptions } from './types';
+export declare function createRouteTreeFromRouteObjects(routes: RouteObject[], options?: RouteTreeOptions): ModernTanstackRootRoute;
+export declare function getModernRouteIdsFromMatches(router: AnyRouter): string[];

package/dist/types/runtime/routeTree/index.d.ts

@@ -0,0 +1,2 @@
+export { pickRouteModuleComponent } from './components';
+export { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches, } from './construction';

package/dist/types/runtime/routeTree/loaders.d.ts

@@ -0,0 +1,4 @@
+import type { RouteObject } from '@modern-js/runtime-utils/router';
+import type { RouteRevalidationState, RouteTreeOptions, TanstackLoaderContext } from './types';
+export declare function createModernShouldReload(shouldRevalidate: unknown, state: RouteRevalidationState): ((ctx: TanstackLoaderContext) => boolean | undefined) | undefined;
+export declare function wrapRouteObjectLoader(route: RouteObject, revalidationState?: RouteRevalidationState, options?: RouteTreeOptions): ((ctx: TanstackLoaderContext) => Promise<unknown>) | undefined;

package/dist/types/runtime/routeTree/paths.d.ts

@@ -0,0 +1,3 @@
+import type { RouteObject } from '@modern-js/runtime-utils/router';
+export declare function toTanstackPath(pathname: string): string;
+export declare function isRouteObjectPathlessLayout(route: RouteObject): boolean;

package/dist/types/runtime/routeTree/staticData.d.ts

@@ -0,0 +1,19 @@
+export declare function mergeModernRouteHandle(route: {
+    config?: {
+        handle?: Record<string, unknown>;
+    } | unknown;
+    handle?: Record<string, unknown>;
+}): {
+    [x: string]: unknown;
+} | undefined;
+export declare function createRouteStaticData(opts: {
+    modernRouteId?: string;
+    modernRouteAction?: unknown;
+    modernRouteHandle?: unknown;
+    modernRouteHasAction?: boolean;
+    modernRouteHasClientLoader?: boolean;
+    modernRouteHasLoader?: boolean;
+    modernRouteIsClientComponent?: boolean;
+    modernRouteLoader?: unknown;
+    modernRouteShouldRevalidate?: unknown;
+}): Record<string, unknown> | undefined;

package/dist/types/runtime/routeTree/tanstackRoutes.d.ts

@@ -0,0 +1,4 @@
+import type { MutableTanstackRoute, TanstackRootRouteOptions, TanstackRouteOptions } from './types';
+export declare function createTanstackRoute(options: TanstackRouteOptions): MutableTanstackRoute;
+export declare function createTanstackRootRoute(options: TanstackRootRouteOptions): MutableTanstackRoute;
+export declare function wrapRouteComponentWithModernContext(route: MutableTanstackRoute, component: unknown, routeId?: string): void;

package/dist/types/runtime/routeTree/types.d.ts

@@ -0,0 +1,75 @@
+import type { RouteObject } from '@modern-js/runtime-utils/router';
+import type { AnyRoute, RootRoute as TanstackRootRoute } from '@tanstack/react-router';
+export type RouteParams = Record<string, string>;
+export type ModernLoader = (args: {
+    request: Request;
+    params: RouteParams;
+    context?: unknown;
+}) => unknown | Promise<unknown>;
+export type ModernShouldRevalidate = (args: {
+    currentParams: RouteParams;
+    currentUrl: URL;
+    nextParams: RouteParams;
+    nextUrl: URL;
+    defaultShouldRevalidate?: boolean;
+}) => boolean | undefined;
+export type TanstackLoaderContext = {
+    abortController?: AbortController;
+    cause?: string;
+    signal?: AbortSignal;
+    context?: {
+        request?: Request;
+        requestContext?: unknown;
+    };
+    location?: string | {
+        publicHref?: string;
+        href?: string;
+        url?: {
+            href?: string;
+        };
+    };
+    params?: RouteParams;
+    route?: {
+        id?: string;
+    };
+};
+export type RouteRevalidationState = {
+    currentParams?: RouteParams;
+    currentUrl?: URL;
+};
+export type ModernRouteObject = RouteObject & {
+    ErrorBoundary?: unknown;
+    HydrateFallback?: unknown;
+    action?: unknown;
+    clientData?: unknown;
+    component?: unknown;
+    config?: {
+        handle?: Record<string, unknown>;
+    } | unknown;
+    file?: string;
+    handle?: Record<string, unknown>;
+    hasAction?: boolean;
+    hasClientLoader?: boolean;
+    hasLoader?: boolean;
+    inValidSSRRoute?: boolean;
+    isClientComponent?: boolean;
+    lazyImport?: () => unknown;
+    loader?: ModernLoader;
+    loaderDeps?: unknown;
+    pendingComponent?: unknown;
+    shouldRevalidate?: ModernShouldRevalidate;
+    validateSearch?: unknown;
+};
+export type MutableTanstackRoute = AnyRoute & {
+    addChildren: (children: AnyRoute[]) => void;
+    id?: string;
+    options: {
+        component?: unknown;
+    };
+};
+export type TanstackRouteOptions = Record<string, unknown>;
+export type TanstackRootRouteOptions = Record<string, unknown>;
+export type ModernTanstackRootRoute = TanstackRootRoute;
+export type RouteTreeOptions = {
+    rscPayloadRouter?: boolean;
+};

package/dist/types/runtime/routeTree.d.ts

@@ -1,9 +1 @@
-import type { RouteObject } from '@modern-js/runtime-utils/router';
-import type { AnyRouter, RootRoute as TanstackRootRoute } from '@tanstack/react-router';
-type ModernTanstackRootRoute = TanstackRootRoute;
-type RouteTreeOptions = {
-    rscPayloadRouter?: boolean;
-};
-export declare function createRouteTreeFromRouteObjects(routes: RouteObject[], options?: RouteTreeOptions): ModernTanstackRootRoute;
-export declare function getModernRouteIdsFromMatches(router: AnyRouter): string[];
-export {};
+export { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches, pickRouteModuleComponent, } from './routeTree/index';

package/dist/types/runtime/rsc/CompositeComponent.d.ts

@@ -1,3 +1,2 @@
-import type React from 'react';
 import { type AnyCompositeComponent, type CompositeComponentProps } from './symbols';
-export declare function CompositeComponent<TComp extends AnyCompositeComponent>(props: CompositeComponentProps<TComp>): React.JSX.Element;
+export declare function CompositeComponent<TComp extends AnyCompositeComponent>(props: CompositeComponentProps<TComp>): import("react").JSX.Element;

package/dist/types/runtime/rsc/RscNodeRenderer.d.ts

@@ -1,5 +1,4 @@
-import type React from 'react';
-import { type AnyRenderableServerComponent } from './symbols';
+import type { AnyRenderableServerComponent } from './symbols';
 export declare function RscNodeRenderer({ data, }: {
     data: AnyRenderableServerComponent;
-}): React.JSX.Element;
+}): import("react").JSX.Element;

package/dist/types/runtime/rsc/client.d.ts

@@ -1,4 +1,5 @@
 import { CompositeComponent } from './CompositeComponent';
+import type { SerializedTanstackRscFlightValue } from './shared';
 import type { AnyCompositeComponent, RscSlotUsageEvent } from './symbols';
 export type { AnyCompositeComponent, AnyRenderableServerComponent, CompositeComponentProps, } from './symbols';
 export { CompositeComponent };
@@ -7,5 +8,6 @@ type SerializedRsc = {
     stream: ReadableStream<Uint8Array>;
     slotUsagesStream?: ReadableStream<RscSlotUsageEvent>;
 };
+export declare function createTanstackRscValueFromFlight(serialized: SerializedTanstackRscFlightValue): AnyCompositeComponent;
 export declare function getTanstackRscSerializationAdapters(): import("@tanstack/router-core").SerializationAdapter<AnyCompositeComponent<Record<string, unknown>, import("react").ReactNode>, SerializedRsc, never>[];
 export declare const rscSerializationAdapter: typeof getTanstackRscSerializationAdapters;

package/dist/types/runtime/rsc/flightSerialization.d.ts

@@ -0,0 +1,3 @@
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function serializeTanstackRscFlightValues(value: unknown, seen?: WeakMap<object, unknown>): unknown;
+export declare function reviveTanstackRscFlightValues(value: unknown, seen?: WeakMap<object, unknown>): Promise<unknown>;

package/dist/types/runtime/rsc/payloadErrors.d.ts

@@ -0,0 +1,6 @@
+import type { ServerPayload } from '@modern-js/runtime/context';
+export declare function shouldRedactServerError(status?: number): boolean;
+export declare function serializePayloadError(error: unknown): unknown;
+export declare function isSerializedNotFound(value: unknown): boolean;
+export declare function toRouteErrors(payload: ServerPayload): Record<string, unknown>;
+export declare function toRouteLoaderData(payload: ServerPayload): Record<string, unknown>;

package/dist/types/runtime/rsc/payloadFetch.d.ts

@@ -0,0 +1,10 @@
+import type { ServerPayload } from '@modern-js/runtime/context';
+type PayloadDecoder = (stream: ReadableStream<Uint8Array>) => Promise<unknown>;
+export declare const payloadFetchCache: Map<string, Promise<ServerPayload>>;
+export declare function decodePayload(stream: ReadableStream<Uint8Array>): Promise<unknown>;
+export declare function isServerPayload(value: unknown): value is ServerPayload;
+export declare function createPayloadFetchKey(request: Request): string;
+export declare function isAbsoluteUrl(value: string): boolean;
+export declare function fetchTanstackRscPayload(request: Request): Promise<ServerPayload>;
+export declare function __setTanstackRscPayloadDecoderForTests(decoder?: PayloadDecoder): void;
+export {};

package/dist/types/runtime/rsc/payloadRouter.d.ts

@@ -1,12 +1,6 @@
 import type { ServerPayload } from '@modern-js/runtime/context';
-type PayloadDecoder = (stream: ReadableStream<Uint8Array>) => Promise<unknown>;
-type TanstackPayloadRouterLike = {
-    state?: {
-        location?: unknown;
-        matches?: unknown;
-        statusCode?: unknown;
-    };
-};
+import type { TanstackPayloadRouterLike } from './payloadRoutes';
+export { __setTanstackRscPayloadDecoderForTests } from './payloadFetch';
 type LoadRouteDataOptions = {
     hasClientLoader?: boolean;
     loadClientData: () => Promise<unknown>;
@@ -20,5 +14,3 @@ export declare function handleTanstackRscRedirect(headers: Headers, basename: st
 export declare function isTanstackRscPayloadNavigationEnabled(): boolean;
 export declare function loadTanstackRscPayload(request: Request): Promise<ServerPayload>;
 export declare function loadTanstackRscRouteData({ hasClientLoader, loadClientData, request, routeId, }: LoadRouteDataOptions): Promise<unknown>;
-export declare function __setTanstackRscPayloadDecoderForTests(decoder?: PayloadDecoder): void;
-export {};

package/dist/types/runtime/rsc/payloadRoutes.d.ts

@@ -0,0 +1,43 @@
+import type { PayloadRoute, ServerPayload } from '@modern-js/runtime/context';
+export type RouterStaticData = {
+    modernRouteAction?: unknown;
+    modernRouteHandle?: unknown;
+    modernRouteHasAction?: unknown;
+    modernRouteHasClientLoader?: unknown;
+    modernRouteHasLoader?: unknown;
+    modernRouteId?: unknown;
+    modernRouteIsClientComponent?: unknown;
+};
+export type RouterRouteLike = {
+    id?: unknown;
+    options?: {
+        index?: unknown;
+        path?: unknown;
+        staticData?: RouterStaticData;
+    };
+    parentRoute?: RouterRouteLike;
+};
+export type RouterMatchLike = {
+    error?: unknown;
+    id?: unknown;
+    loaderData?: unknown;
+    params?: unknown;
+    pathname?: unknown;
+    pathnameBase?: unknown;
+    route?: RouterRouteLike;
+    routeId?: unknown;
+};
+export type TanstackPayloadRouterLike = {
+    state?: {
+        location?: unknown;
+        matches?: unknown;
+        statusCode?: unknown;
+    };
+};
+export declare function toPlainRecord(value: unknown): Record<string, unknown>;
+export declare function toPlainLocation(location: unknown): ServerPayload['location'];
+export declare function getRouteId(match: RouterMatchLike): string | undefined;
+export declare function getRouteStaticData(match: RouterMatchLike): RouterStaticData;
+export declare function getRouteParentId(match: RouterMatchLike): string | undefined;
+export declare function toRoutePath(match: RouterMatchLike): string | undefined;
+export declare function toPayloadRoute(match: RouterMatchLike): PayloadRoute | undefined;

package/dist/types/runtime/rsc/payloadStorage.d.ts

@@ -0,0 +1,5 @@
+import type { ServerPayload } from '@modern-js/runtime/context';
+import type { TanstackRouterWithServerSsr } from '../ssrTypes';
+export declare const setTanstackRscServerPayload: (payload: ServerPayload) => void;
+export declare const setTanstackRscRouter: (router: TanstackRouterWithServerSsr) => void;
+export declare const getTanstackRscRouter: () => TanstackRouterWithServerSsr | undefined;

package/dist/types/runtime/rsc/shared.d.ts

@@ -0,0 +1,19 @@
+import type React from 'react';
+import { type AnyCompositeComponent, type AnyRenderableServerComponent, type RscSlotUsageEvent } from './symbols';
+export declare const TANSTACK_RSC_FLIGHT_VALUE = "__modernTanstackRsc";
+export type SerializedTanstackRscFlightValue = {
+    [TANSTACK_RSC_FLIGHT_VALUE]: true;
+    kind: 'renderable' | 'composite';
+    slotUsagesStream?: ReadableStream<RscSlotUsageEvent>;
+    stream: ReadableStream<Uint8Array>;
+};
+export declare function isSerializedTanstackRscFlightValue(value: unknown): value is SerializedTanstackRscFlightValue;
+export declare function EmptyFallback(): null;
+export declare function selectTreePath(tree: unknown, path: string[]): React.ReactNode;
+type RenderSelectedTreeSource = AnyRenderableServerComponent | AnyCompositeComponent;
+type RenderSelectedTreeOptions = {
+    getTree?: (() => unknown) | undefined;
+    missingTreeError: string;
+};
+export declare function renderSelectedTree(src: RenderSelectedTreeSource, { getTree, missingTreeError, }: RenderSelectedTreeOptions): React.ReactNode;
+export {};

package/dist/types/runtime/rsc/treeGetter.d.ts

@@ -0,0 +1 @@
+export declare function createTreeGetterFromFlightStream(stream: ReadableStream<Uint8Array>): () => any;

package/dist/types/runtime/ssrManagedTags.d.ts

@@ -0,0 +1,7 @@
+import type { AnyRouter } from '@tanstack/react-router';
+import type { TanstackRouterWithServerSsr } from './ssrTypes';
+export declare function waitForRouterSerialization(tanstackRouter: TanstackRouterWithServerSsr): Promise<void>;
+export declare function routerManagedTagsToHtml(tags: unknown): string[];
+export declare function createGetSsrHref(request: Request): string;
+export declare function collectRouterErrors(tanstackRouter: AnyRouter): Record<string, unknown> | undefined;
+export declare function attachServerSsrUtils(router: TanstackRouterWithServerSsr): Promise<void>;

package/dist/types/runtime/ssrPreload.d.ts

@@ -0,0 +1,2 @@
+import type { TanstackRouterWithServerSsr } from './ssrTypes';
+export declare function preloadMatchedRouteComponents(tanstackRouter: TanstackRouterWithServerSsr): Promise<void>;

package/dist/types/runtime/ssrTypes.d.ts

@@ -0,0 +1,43 @@
+import type { RequestContext } from '@modern-js/runtime-utils/node';
+import type { AnyRouter } from '@tanstack/react-router';
+export type ModernTanstackRouterContext = {
+    request: Request;
+    requestContext: RequestContext<Record<string, unknown>>;
+};
+export type RouterManagedTag = {
+    attrs?: Record<string, unknown>;
+    children?: unknown;
+    tag?: unknown;
+};
+export type RouterMatchWithError = {
+    error?: unknown;
+    route?: {
+        id?: unknown;
+        options?: RouterRouteOptions;
+    };
+    routeId?: unknown;
+};
+export type RouterRouteOptions = {
+    component?: unknown;
+    errorComponent?: unknown;
+    notFoundComponent?: unknown;
+    pendingComponent?: unknown;
+};
+export type RouterRouteWithOptions = {
+    options?: RouterRouteOptions;
+};
+export type TanstackRouterWithServerSsr = AnyRouter & {
+    resolveRedirect?: (redirect: Response) => Response;
+    routesById?: Record<string, RouterRouteWithOptions>;
+    serverSsr?: {
+        cleanup?: () => void;
+        dehydrate?: () => Promise<void> | void;
+        isSerializationFinished?: () => boolean;
+        onSerializationFinished?: (listener: () => void) => void;
+        takeBufferedScripts?: () => unknown;
+    };
+    state: AnyRouter['state'] & {
+        matches?: unknown;
+        redirect?: Response;
+    };
+};

package/dist/types/runtime/state.d.ts

@@ -1,5 +1,5 @@
+import { type InternalRouterRuntimeState } from '@modern-js/runtime/context';
 import type { AnyRouter } from '@tanstack/react-router';
-import type { InternalRouterRuntimeState } from './types';
 /**
  * Router runtime state as published by the TanStack router provider into the
  * runtime-context extension slot.

package/dist/types/runtime/submitAction.d.ts

@@ -0,0 +1,14 @@
+import type { AnyRouter } from '@tanstack/react-router';
+import type { SubmitOptions, SubmitTarget } from './formData';
+export declare class RouteActionResponseError<TData = unknown> extends Error {
+    readonly response: Response;
+    readonly data: TData;
+    constructor(response: Response, data: TData);
+}
+export declare function submitRouteAction({ router, target, options, isFetcher, onInvalidateStart, }: {
+    router: AnyRouter;
+    target: SubmitTarget;
+    options?: SubmitOptions;
+    isFetcher?: boolean;
+    onInvalidateStart?: () => void;
+}): Promise<any>;

package/dist/types/runtime/types.d.ts

@@ -1,51 +1,8 @@
+import type { ModernRoute, RouterFramework } from '@modern-js/runtime/context';
 import type { RouteObject } from '@modern-js/runtime-utils/router';
 import type React from 'react';
-export type BuiltInRouterFramework = 'react-router' | 'tanstack';
-export type RouterFramework = BuiltInRouterFramework | (string & {});
-export type ModernRoute = {
-    type: 'nested' | 'page';
-    path?: string;
-    id?: string;
-    component?: React.ComponentType | string;
-    children?: ModernRoute[];
-    [key: string]: any;
-};
-export type RouterRouteMatchSnapshot = {
-    routeId: string;
-    assetRouteId?: string;
-    pathname?: string;
-    params?: Record<string, string>;
-};
-export type InternalRouterServerSnapshot = {
-    framework?: RouterFramework;
-    basename?: string;
-    statusCode?: number;
-    errors?: Record<string, unknown>;
-    routerData?: {
-        loaderData?: Record<string, unknown>;
-        errors?: Record<string, unknown>;
-    };
-    hydrationScript?: string;
-    hydrationScripts?: string[];
-    matchedRouteIds?: string[];
-    matches?: RouterRouteMatchSnapshot[];
-};
-export type InternalRouterRuntimeState = {
-    framework: RouterFramework;
-    basename?: string;
-    instance?: unknown;
-    hydrationScript?: string;
-    hydrationScripts?: string[];
-    matchedRouteIds?: string[];
-    matches?: RouterRouteMatchSnapshot[];
-    serverSnapshot?: InternalRouterServerSnapshot;
-    cleanup?: () => void | Promise<void>;
-};
-/**
- * TanStack-specific router config. Unlike the react-router provider config,
- * this intentionally has no `oldVersion`/`future` fields — those are
- * react-router-only knobs with no meaning here.
- */
+export type { BuiltInRouterFramework, InternalRouterRuntimeState, InternalRouterServerSnapshot, LoaderFunction, LoaderFunctionArgs, ModernRoute, RouterFramework, RouterRouteMatchSnapshot, RouterServerPrepareResult, } from '@modern-js/runtime/context';
+/** TanStack-specific router config. */
 export type RouterConfig = {
     framework?: RouterFramework;
     routesConfig: {

package/dist/types/runtime/utils.d.ts

@@ -8,30 +8,9 @@ type RouterConfig = {
         routes?: ModernRoute[];
     };
 };
-type GlobalAppProps = {
-    Component: React.ComponentType;
-    [key: string]: unknown;
-};
-export type ModernRouteObject = RouteObject & {
-    isClientComponent?: boolean;
-    hasClientLoader?: boolean;
-    hasLoader?: boolean;
-    hasAction?: boolean;
-    inValidSSRRoute?: boolean;
-    lazyImport?: () => Promise<{
-        default: React.ComponentType;
-    }>;
-};
-export declare function getRouteObjects(routes: ModernRoute[], { globalApp, ssrMode, props, }: {
-    globalApp?: React.ComponentType<GlobalAppProps>;
-    ssrMode?: SSRMode;
-    props?: Record<string, unknown>;
-}): RouteObject[];
-export declare function createRouteObjectsFromConfig({ routesConfig, props, ssrMode, }: {
+export declare function createTanstackRouteObjectsFromConfig({ routesConfig, }: {
     routesConfig: RouterConfig['routesConfig'];
     props?: Record<string, unknown>;
     ssrMode?: SSRMode;
 }): RouteObject[] | null;
-export declare const urlJoin: (...parts: string[]) => string;
-export declare function standardSlash(str: string): string;
 export {};

package/package.json

@@ -18,7 +18,7 @@
     "modern.js",
     "tanstack-router"
   ],
-  "version": "3.5.0-ultramodern.30",
+  "version": "3.5.0-ultramodern.31",
   "engines": {
     "node": ">=20"
   },
@@ -55,6 +55,20 @@
         "module": "./dist/esm/runtime/router.mjs"
       },
       "default": "./dist/esm/runtime/router.mjs"
+    },
+    "./runtime/rsc/client": {
+      "types": "./dist/types/runtime/rsc/client.d.ts",
+      "node": {
+        "module": "./dist/esm/runtime/rsc/client.mjs"
+      },
+      "default": "./dist/esm/runtime/rsc/client.mjs"
+    },
+    "./runtime/rsc/server": {
+      "types": "./dist/types/runtime/rsc/server.d.ts",
+      "node": {
+        "module": "./dist/esm/runtime/rsc/server.mjs"
+      },
+      "default": "./dist/esm/runtime/rsc/server.mjs"
     }
   },
   "typesVersions": {
@@ -70,6 +84,12 @@
       ],
       "runtime/router": [
         "./dist/types/runtime/router.d.ts"
+      ],
+      "runtime/rsc/client": [
+        "./dist/types/runtime/rsc/client.d.ts"
+      ],
+      "runtime/rsc/server": [
+        "./dist/types/runtime/rsc/server.d.ts"
       ]
     }
   },
@@ -77,14 +97,15 @@
     "@swc/helpers": "^0.5.23",
     "@tanstack/react-router": "1.170.16",
     "@tanstack/router-core": "1.171.13",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.30",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.30",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.30",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.30"
+    "react-server-dom-rspack": "0.0.2",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.31",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.31",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.31",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.31"
   },
   "peerDependencies": {
-    "@modern-js/app-tools": "3.5.0-ultramodern.30",
-    "@modern-js/runtime": "3.5.0-ultramodern.30",
+    "@modern-js/app-tools": "3.5.0-ultramodern.31",
+    "@modern-js/runtime": "3.5.0-ultramodern.31",
     "react": "^19.2.7",
     "react-dom": "^19.2.7"
   },
@@ -99,8 +120,8 @@
     "@typescript/native-preview": "7.0.0-dev.20260628.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.30",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.30",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.31",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.31",
     "@scripts/rstest-config": "2.66.0"
   },
   "sideEffects": [

package/rstest.config.mts

@@ -33,6 +33,7 @@ export default {
         'tests/router/register.test.ts',
         'tests/router/routeHooks.test.ts',
         'tests/router/rsc.test.tsx',
+        'tests/router/ssrPreload.test.ts',
         'tests/router/tanstackTypes.test.ts',
         'tests/router/routeTree.test.ts',
       ],