@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

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

@@ -0,0 +1,121 @@
+import "node:module";
+import { formDataToTextPlain, formDataToUrlSearchParams, toFormData } from "./formData.mjs";
+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 = toFormData(target);
+    const resolved = resolveRouteHandlers(router, actionTo);
+    if ('get' === method) {
+        const search = 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(formDataToUrlSearchParams(formData).entries()));
+    } else if (encType.includes('text/plain')) {
+        headers.set('Content-Type', 'text/plain;charset=UTF-8');
+        body = formDataToTextPlain(formData);
+    } else if (encType.includes('application/x-www-form-urlencoded')) {
+        headers.set('Content-Type', 'application/x-www-form-urlencoded;charset=UTF-8');
+        body = 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;
+}
+export { RouteActionResponseError, submitRouteAction };

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: 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__*/ 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 { toTanstackPath } from '../../runtime/routeTree/paths';
+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,12 @@
+import type { AppToolsContext } from '@modern-js/app-tools';
+import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
+type RouteForCli = NestedRouteForCli | PageRoute;
+export declare function generateTanstackRouterTypesSourceForEntry(opts: {
+    appContext: AppToolsContext;
+    entryName: string;
+    generatedDirName?: string;
+    routes: RouteForCli[];
+}): Promise<{
+    routerGenTs: string;
+}>;
+export {};

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 @@
+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,10 @@
+import { type AnyRouter } from '@tanstack/react-router';
+export type WindowWithTanstackSsr = Window & {
+    $_TSR?: unknown;
+};
+export declare function hydrateTanstackRouter(router: AnyRouter): Promise<unknown>;
+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,24 @@
+import type React from 'react';
+export type SubmitTarget = HTMLFormElement | FormData | URLSearchParams | Record<string, string | number | boolean | null | undefined>;
+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>;
+export {};

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

@@ -1,3 +1,5 @@
+import { isAbsoluteUrl } from './shared/isAbsoluteUrl';
+export { isAbsoluteUrl };
 /** Router context shape used by the generated TanStack router types. */
 export type ModernRouterContext = {
     request?: Request;
@@ -11,7 +13,6 @@ export declare function isRedirectResponse(res: Response): boolean;
  * the Modern Response handling would lose `to`-based (internal) targets.
  */
 export declare function isTanstackRedirect(value: unknown): boolean;
-export declare function isAbsoluteUrl(value: string): boolean;
 /**
  * Re-throw a Modern.js `Location` redirect as a TanStack redirect.
  *

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,38 @@
+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';
+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;
+};
+type TanstackRouteConfig = {
+    mergedConfig: RouterConfig;
+    finalRouteConfig: RouterConfig['routesConfig'];
+    hasConfiguredRoutes: boolean;
+};
+export declare function getMergedRouterConfig(api: TanstackRouterPluginAPI, userConfig: Partial<RouterConfig>): RouterConfig;
+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/register.d.ts

@@ -1,9 +1,10 @@
-import { Form, RouteActionResponseError, useFetcher } from './dataMutation';
-export declare const tanstackRouterCompatBindings: {
-    Form: typeof Form;
-    Link: <TRouter extends import("@tanstack/router-core").AnyRouter = import("@tanstack/router-core").AnyRouter, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = "">(props: import("./prefetchLink").LinkProps<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => import("react").ReactElement;
-    NavLink: <TRouter extends import("@tanstack/router-core").AnyRouter = import("@tanstack/router-core").AnyRouter, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = "">(props: import("./prefetchLink").LinkProps<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => import("react").ReactElement;
-    Outlet: import("react").MemoExoticComponent<() => import("react").JSX.Element>;
-    RouteActionResponseError: typeof RouteActionResponseError;
-    useFetcher: typeof useFetcher;
-};
+/**
+ * Registers TanStack in the @modern-js/runtime compatibility registry.
+ * Runtime entries bind the exported local factory into their own provider
+ * realm; registration remains for older runtime wrappers and mixed cohorts.
+ *
+ * This module is intentionally side-effectful (see `sideEffects` in
+ * package.json).
+ */
+import { type RouterProviderFactory } from '@modern-js/runtime/context';
+export declare const tanstackRouterProviderFactory: RouterProviderFactory;

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;