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

package/dist/esm-node/runtime/rsc/shared.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+import { RSC_PROXY_GET_TREE, RSC_PROXY_PATH } from "./symbols.mjs";
+const TANSTACK_RSC_FLIGHT_VALUE = '__modernTanstackRsc';
+function isSerializedTanstackRscFlightValue(value) {
+    return Boolean(value) && 'object' == typeof value && true === value[TANSTACK_RSC_FLIGHT_VALUE] && ('renderable' === value.kind || 'composite' === value.kind) && value.stream instanceof ReadableStream;
+}
+function EmptyFallback() {
+    return null;
+}
+function selectTreePath(tree, path) {
+    let current = tree;
+    for (const key of path){
+        if (null === current || 'object' != typeof current) return null;
+        current = current[key];
+    }
+    return current;
+}
+function renderSelectedTree(src, { getTree = src[RSC_PROXY_GET_TREE], missingTreeError }) {
+    if (!getTree) throw new Error(missingTreeError);
+    return selectTreePath(getTree(), src[RSC_PROXY_PATH] || []);
+}
+export { EmptyFallback, TANSTACK_RSC_FLIGHT_VALUE, isSerializedTanstackRscFlightValue, renderSelectedTree, selectTreePath };

package/dist/esm-node/runtime/rsc/treeGetter.mjs

@@ -0,0 +1,35 @@
+import "node:module";
+"use client";
+import { use } from "react";
+let modernRscClientRuntimePromise;
+function loadModernRscClientRuntime() {
+    modernRscClientRuntimePromise ??= import("@modern-js/runtime/rsc/client").then((runtime)=>{
+        runtime.setServerCallback(runtime.callServer);
+        return runtime;
+    });
+    return modernRscClientRuntimePromise;
+}
+async function createFromFlightStream(stream) {
+    if ("u" < typeof window) {
+        const runtime = await import("react-server-dom-rspack/client.edge");
+        return runtime.createFromReadableStream(stream);
+    }
+    const runtime = await loadModernRscClientRuntime();
+    return runtime.createFromReadableStream(stream, {
+        callServer: runtime.callServer
+    });
+}
+function createTreeGetterFromFlightStream(stream) {
+    let ready = false;
+    let tree;
+    const treePromise = createFromFlightStream(stream).then((value)=>{
+        tree = value;
+        ready = true;
+        return value;
+    });
+    return ()=>{
+        if (ready) return tree;
+        return use(treePromise);
+    };
+}
+export { createTreeGetterFromFlightStream };

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

@@ -0,0 +1,54 @@
+import "node:module";
+async function waitForRouterSerialization(tanstackRouter) {
+    const serverSsr = tanstackRouter.serverSsr;
+    if (!serverSsr || 'function' != typeof serverSsr.onSerializationFinished || serverSsr.isSerializationFinished?.()) return;
+    await new Promise((resolve)=>{
+        serverSsr.onSerializationFinished?.(resolve);
+    });
+}
+function htmlEscapeAttr(value) {
+    return value.replace(/&/g, '&').replace(/"/g, '"');
+}
+function routerManagedTagToHtml(tag) {
+    if (!tag || 'object' != typeof tag) return '';
+    const managedTag = tag;
+    if (!managedTag || "script" !== managedTag.tag) return '';
+    const attrs = managedTag.attrs || {};
+    const attrsStr = Object.entries(attrs).filter(([, v])=>null != v && false !== v).map(([k, v])=>{
+        const name = 'className' === k ? 'class' : k;
+        if (true === v) return name;
+        return `${name}="${htmlEscapeAttr(String(v))}"`;
+    }).join(' ');
+    const open = attrsStr.length ? `<script ${attrsStr}>` : "<script>";
+    const children = 'string' == typeof managedTag.children ? managedTag.children : '';
+    return `${open}${children}</script>`;
+}
+function routerManagedTagsToHtml(tags) {
+    const normalizedTags = Array.isArray(tags) ? tags : [
+        tags
+    ];
+    return normalizedTags.map(routerManagedTagToHtml).filter(Boolean);
+}
+function createGetSsrHref(request) {
+    const url = new URL(request.url);
+    return `${url.pathname}${url.search}${url.hash}`;
+}
+function collectRouterErrors(tanstackRouter) {
+    const state = tanstackRouter.state;
+    const matches = Array.isArray(state.matches) ? state.matches : [];
+    const errors = matches.reduce((acc, match)=>{
+        if (!match.error) return acc;
+        const routeId = 'string' == typeof match.routeId ? match.routeId : 'string' == typeof match.route?.id ? match.route.id : `match-${Object.keys(acc).length}`;
+        acc[routeId] = match.error;
+        return acc;
+    }, {});
+    return Object.keys(errors).length > 0 ? errors : void 0;
+}
+async function attachServerSsrUtils(router) {
+    const { attachRouterServerSsrUtils } = await import("@tanstack/router-core/ssr/server");
+    attachRouterServerSsrUtils({
+        router,
+        manifest: void 0
+    });
+}
+export { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml, waitForRouterSerialization };

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

@@ -0,0 +1,52 @@
+import "node:module";
+function isPromiseLike(value) {
+    return Boolean(value && 'function' == typeof value.then);
+}
+function isPreloadableRouteComponent(component) {
+    if (!component || 'function' != typeof component) return false;
+    const preloadable = component;
+    return 'function' == typeof preloadable.load || 'function' == typeof preloadable.preload;
+}
+function isReactLazyRouteComponent(component) {
+    return null != component && 'object' == typeof component && 'function' == typeof component._init && '_payload' in component;
+}
+async function preloadReactLazyRouteComponent(component) {
+    try {
+        component._init?.(component._payload);
+    } catch (thrown) {
+        if (!isPromiseLike(thrown)) throw thrown;
+        await thrown;
+        component._init?.(component._payload);
+    }
+}
+async function preloadRouteComponent(component, preloadedComponents) {
+    if (isReactLazyRouteComponent(component)) {
+        if (preloadedComponents.has(component)) return;
+        preloadedComponents.add(component);
+        await preloadReactLazyRouteComponent(component);
+        return;
+    }
+    if (!isPreloadableRouteComponent(component)) return;
+    if (preloadedComponents.has(component)) return;
+    preloadedComponents.add(component);
+    if ('function' == typeof component.load) return void await component.load({});
+    await component.preload?.({});
+}
+async function preloadMatchedRouteComponents(tanstackRouter) {
+    const matches = Array.isArray(tanstackRouter.state.matches) ? tanstackRouter.state.matches : [];
+    const routesById = tanstackRouter.routesById || {};
+    const preloadedComponents = new Set();
+    await Promise.all(matches.map(async (match)=>{
+        const routeId = 'string' == typeof match.routeId ? match.routeId : 'string' == typeof match.route?.id ? match.route.id : void 0;
+        const route = routeId ? routesById[routeId] : match.route;
+        const options = route?.options;
+        if (!options) return;
+        await Promise.all([
+            preloadRouteComponent(options.component, preloadedComponents),
+            preloadRouteComponent(options.pendingComponent, preloadedComponents),
+            preloadRouteComponent(options.errorComponent, preloadedComponents),
+            preloadRouteComponent(options.notFoundComponent, preloadedComponents)
+        ]);
+    }));
+}
+export { preloadMatchedRouteComponents };

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

@@ -0,0 +1 @@
+import "node:module";

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,36 +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>;
-/**
- * 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>;
 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 {};