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

package/dist/esm-node/runtime/utils.mjs

@@ -1,84 +1,56 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
 import react from "react";
-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;
+function withGlobalLayout(Component, globalApp) {
+    if (!globalApp) return Component;
+    const GlobalLayout = globalApp;
+    return function(props) {
+        return /*#__PURE__*/ 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__*/ 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);
-    }
-    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: 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__*/ react.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__*/ react.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);
 }
-export { createRouteObjectsFromConfig, getRouteObjects, standardSlash, urlJoin };
+export { createTanstackRouteObjectsFromConfig };

package/dist/types/cli/artifacts.d.ts

@@ -0,0 +1,33 @@
+import type { AppToolsContext } from '@modern-js/app-tools';
+import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
+export declare function writeTanstackRegisterFile(opts: {
+    entries: string[];
+    generatedDirName?: string;
+    runtimeModule?: string;
+    srcDirectory: string;
+    canonicalRoutes?: Record<string, string> | null;
+    i18nRuntimeModule?: string;
+}): Promise<void>;
+export declare function writeTanstackRouterTypesForEntries(opts: {
+    appContext: AppToolsContext;
+    generatedDirName?: string;
+    routesByEntry: Record<string, (NestedRouteForCli | PageRoute)[]>;
+    /**
+     * Whether `@modern-js/plugin-i18n` is actually installed in the app. The
+     * `register.gen.d.ts` augmentation of '@modern-js/plugin-i18n/runtime' is
+     * only emitted when this is true — otherwise apps with a hand-rolled
+     * `/:lang/` param would fail typechecking on an unresolvable module.
+     */
+    i18nPluginInstalled?: boolean;
+}): Promise<void>;
+/**
+ * Headless regeneration of `router.gen.ts` / `register.gen.d.ts` for a generated
+ * app, without running a full dev/build. Drives the app-tools analyze `onPrepare`
+ * (which fires `generateEntryCode`) and returns before any bundling — the app's
+ * own registered plugin-tanstack writes the artifacts via its `generateEntryCode`
+ * subscriber. Reuses the exact hook dev/build use, so there is no scanning drift.
+ */
+export declare function generateTanstackRouteArtifacts(opts: {
+    appDirectory: string;
+    version?: string;
+}): Promise<void>;

package/dist/types/cli/index.d.ts

@@ -1,6 +1,6 @@
-import type { AppTools, AppToolsContext, CliPlugin } from '@modern-js/app-tools';
-import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 import { type TanstackRouteCodeSplittingOption } from './routeSplitting';
+export { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries, } from './artifacts';
 export type { TanstackRouteCodeSplittingOption, TanstackRsbuildRouteSplittingProfile, } from './routeSplitting';
 export { createTanstackRsbuildRouteSplittingProfile, resolveTanstackRouteCodeSplittingEnabled, } from './routeSplitting';
 export { type CollectCanonicalRoutesOptions, collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry, } from './tanstackTypes';
@@ -9,25 +9,5 @@ export type TanstackRouterPluginOptions = {
     generatedDirName?: string;
     routeCodeSplitting?: TanstackRouteCodeSplittingOption;
 };
-export declare function writeTanstackRegisterFile(opts: {
-    entries: string[];
-    generatedDirName?: string;
-    runtimeModule?: string;
-    srcDirectory: string;
-    canonicalRoutes?: Record<string, string> | null;
-    i18nRuntimeModule?: string;
-}): Promise<void>;
-export declare function writeTanstackRouterTypesForEntries(opts: {
-    appContext: AppToolsContext;
-    generatedDirName?: string;
-    routesByEntry: Record<string, (NestedRouteForCli | PageRoute)[]>;
-    /**
-     * Whether `@modern-js/plugin-i18n` is actually installed in the app. The
-     * `register.gen.d.ts` augmentation of '@modern-js/plugin-i18n/runtime' is
-     * only emitted when this is true — otherwise apps with a hand-rolled
-     * `/:lang/` param would fail typechecking on an unresolvable module.
-     */
-    i18nPluginInstalled?: boolean;
-}): Promise<void>;
 export declare function tanstackRouterPlugin(options?: TanstackRouterPluginOptions): CliPlugin<AppTools>;
 export default tanstackRouterPlugin;

package/dist/types/cli/tanstackTypes/canonicalRoutes.d.ts

@@ -0,0 +1,22 @@
+import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
+export type CollectCanonicalRoutesOptions = {
+    /**
+     * Whether a leading `:lang`/`:locale`/`:language` route param may be
+     * treated as an i18n locale prefix. This MUST only be enabled when
+     * `@modern-js/plugin-i18n` is actually installed: the emitted
+     * `declare module '@modern-js/plugin-i18n/runtime'` augmentation breaks
+     * typechecking (TS2664) for apps that hand-roll a `/:lang/` param without
+     * the plugin. Routes carrying `modernCanonicalPath` metadata are always
+     * honored — only plugin-i18n produces them.
+     */
+    localeParamHeuristic?: boolean;
+};
+/**
+ * Derive the canonical (language-agnostic) route map for an entry: the
+ * leading locale param is stripped and localized physical variants (routes
+ * carrying `modernCanonicalPath` metadata from `@modern-js/plugin-i18n`)
+ * collapse to their canonical pattern. Returns `null` when the entry has no
+ * i18n routing surface (no locale param and no localized variants), so plain
+ * TanStack apps never get a `@modern-js/plugin-i18n` module augmentation.
+ */
+export declare function collectCanonicalRoutesForEntry(routes: (NestedRouteForCli | PageRoute)[], options?: CollectCanonicalRoutesOptions): Record<string, string> | null;

package/dist/types/cli/tanstackTypes/shared.d.ts

@@ -0,0 +1,20 @@
+import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
+export declare function toTanstackPath(pathname: string): string;
+export declare function resolveFileNoExt(inputNoExtPath: string): Promise<string | null>;
+export declare function quote(str: string): string;
+export declare function normalizeRelativeImport(p: string): string;
+export declare function pickModernLoaderModule(route: NestedRouteForCli | PageRoute): {
+    loaderPath: string;
+    inline: boolean;
+} | null;
+export declare function pickRouteSearchContractModules(route: NestedRouteForCli | PageRoute): {
+    validateSearchPath: string | null;
+    loaderDepsPath: string | null;
+};
+export declare function isPathlessLayout(route: NestedRouteForCli | PageRoute): boolean;
+export declare function isIndexRoute(route: NestedRouteForCli | PageRoute): boolean;
+export declare function createRouteStaticDataSnippet(opts: {
+    modernRouteId?: string;
+    loaderName?: string | null;
+    actionName?: string | null;
+}): string | null;

package/dist/types/cli/tanstackTypes/source.d.ts

@@ -0,0 +1,10 @@
+import type { AppToolsContext } from '@modern-js/app-tools';
+import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
+export declare function generateTanstackRouterTypesSourceForEntry(opts: {
+    appContext: AppToolsContext;
+    entryName: string;
+    generatedDirName?: string;
+    routes: (NestedRouteForCli | PageRoute)[];
+}): Promise<{
+    routerGenTs: string;
+}>;

package/dist/types/cli/tanstackTypes.d.ts

@@ -1,31 +1,3 @@
-import type { AppToolsContext } from '@modern-js/app-tools';
-import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
-export type CollectCanonicalRoutesOptions = {
-    /**
-     * Whether a leading `:lang`/`:locale`/`:language` route param may be
-     * treated as an i18n locale prefix. This MUST only be enabled when
-     * `@modern-js/plugin-i18n` is actually installed: the emitted
-     * `declare module '@modern-js/plugin-i18n/runtime'` augmentation breaks
-     * typechecking (TS2664) for apps that hand-roll a `/:lang/` param without
-     * the plugin. Routes carrying `modernCanonicalPath` metadata are always
-     * honored — only plugin-i18n produces them.
-     */
-    localeParamHeuristic?: boolean;
-};
-/**
- * Derive the canonical (language-agnostic) route map for an entry: the
- * leading locale param is stripped and localized physical variants (routes
- * carrying `modernCanonicalPath` metadata from `@modern-js/plugin-i18n`)
- * collapse to their canonical pattern. Returns `null` when the entry has no
- * i18n routing surface (no locale param and no localized variants), so plain
- * TanStack apps never get a `@modern-js/plugin-i18n` module augmentation.
- */
-export declare function collectCanonicalRoutesForEntry(routes: (NestedRouteForCli | PageRoute)[], options?: CollectCanonicalRoutesOptions): Record<string, string> | null;
-export declare function generateTanstackRouterTypesSourceForEntry(opts: {
-    appContext: AppToolsContext;
-    entryName: string;
-    generatedDirName?: string;
-    routes: (NestedRouteForCli | PageRoute)[];
-}): Promise<{
-    routerGenTs: string;
-}>;
+export type { CollectCanonicalRoutesOptions } from './tanstackTypes/canonicalRoutes';
+export { collectCanonicalRoutesForEntry } from './tanstackTypes/canonicalRoutes';
+export { generateTanstackRouterTypesSourceForEntry } from './tanstackTypes/source';

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

@@ -0,0 +1,3 @@
+export declare const BLOCKING_SUBSCRIBE_SYMBOL: unique symbol;
+export declare const BLOCKING_STATE_SYMBOL: unique symbol;
+export declare function wrapRouterSubscribeWithBlockState(router: unknown, getBlockNavState?: () => boolean): void;

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

@@ -0,0 +1 @@
+export declare function isSegmentPrefix(pathname: string, base: string): boolean;

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

@@ -0,0 +1,19 @@
+import { type AnyRouter } from '@tanstack/react-router';
+export type WindowWithTanstackSsr = Window & {
+    $_TSR?: unknown;
+};
+export type RouterHydrationRecord = {
+    error?: unknown;
+    promise: Promise<unknown>;
+    status: 'pending' | 'fulfilled' | 'rejected';
+};
+export declare const routerHydrationRecords: WeakMap<AnyRouter, RouterHydrationRecord>;
+export declare function getCachedRouteModule(routeId: string): unknown;
+export declare function preloadHydratedRouteComponents(router: AnyRouter): Promise<void>;
+export declare function hydrateTanstackRouter(router: AnyRouter): Promise<unknown>;
+export declare function getTanstackSsrHydrationRecord(router: AnyRouter): RouterHydrationRecord;
+export declare function getTanstackSsrHydrationPromise(router: AnyRouter): Promise<unknown>;
+export declare function hasTanstackSsrHydrationRecord(router: AnyRouter): boolean;
+export declare function ModernRouterClient({ router }: {
+    router: AnyRouter;
+}): import("react").FunctionComponentElement<import("@tanstack/react-router").RouterProps<AnyRouter, Record<string, any>>>;

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

@@ -1,16 +1,8 @@
 import type React from 'react';
-type SubmitTarget = HTMLFormElement | FormData | URLSearchParams | Record<string, string | number | boolean | null | undefined>;
-export type SubmitOptions = {
-    action?: string;
-    method?: string;
-    encType?: string;
-};
+import type { SubmitOptions, SubmitTarget } from './formData';
+export type { SubmitOptions } from './formData';
+export { RouteActionResponseError } from './submitAction';
 export type FetcherState = 'idle' | 'submitting' | 'loading';
-export declare class RouteActionResponseError<TData = unknown> extends Error {
-    readonly response: Response;
-    readonly data: TData;
-    constructor(response: Response, data: TData);
-}
 export type FormProps = Omit<React.FormHTMLAttributes<HTMLFormElement>, 'onSubmit' | 'action'> & {
     action?: string;
     onSubmit?: React.FormEventHandler<HTMLFormElement>;
@@ -26,4 +18,3 @@ export type Fetcher = {
     submit: (target: SubmitTarget, options?: FetcherSubmitOptions) => Promise<void>;
 };
 export declare function useFetcher(): Fetcher;
-export {};

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/pluginShared.d.ts

@@ -0,0 +1,39 @@
+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>;
+    [key: string]: unknown;
+};
+type RuntimeInterrupt = (value?: unknown) => unknown;
+export type TanstackRouterPluginAPI = {
+    getRuntimeConfig: () => TanstackRouterRuntimeConfig;
+    getHooks: () => RouterExtendsHooks;
+    onBeforeRender: (listener: (context: TInternalRuntimeContext, interrupt: RuntimeInterrupt) => unknown) => void;
+    wrapRoot: (listener: (App: any) => any) => void;
+    [key: string]: any;
+};
+export type TanstackRouterRuntimePlugin = {
+    name?: string;
+    registryHooks?: RouterExtendsHooks;
+    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 {};