@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.99 → 3.4.0-ultramodern.1

package/dist/esm/cli/tanstackTypes.mjs

@@ -1,17 +1,6 @@
-import { findExists, formatImportPath, fs, slash } from "@modern-js/utils";
+import { getPathWithoutExt, makeLegalIdentifier } from "@modern-js/runtime/cli";
+import { findExists, formatImportPath, slash } from "@modern-js/utils";
 import path from "path";
-const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
-const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
-const forbidList = new Set(`${reservedWords} ${builtins}`.split(' '));
-function makeLegalIdentifier(str) {
-    const identifier = str.replace(/-(\w)/g, (_, letter)=>letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, '_');
-    if (/\d/.test(identifier[0]) || forbidList.has(identifier)) return `_${identifier}`;
-    return identifier || '_';
-}
-function getPathWithoutExt(filename) {
-    const extname = path.extname(filename);
-    return extname ? filename.slice(0, -extname.length) : filename;
-}
 const JS_OR_TS_EXTS = [
     '.js',
     '.jsx',
@@ -77,16 +66,78 @@ function createRouteStaticDataSnippet(opts) {
     if (!staticDataLines.length) return null;
     return `staticData: createRouteStaticData({\n    ${staticDataLines.join('\n    ')}\n  }),`;
 }
-async function isTanstackRouterFrameworkEnabled(appContext) {
-    const runtimeConfigBase = path.join(appContext.srcDirectory, appContext.runtimeConfigFile);
-    const runtimeConfigFile = findExists(JS_OR_TS_EXTS.map((ext)=>`${runtimeConfigBase}${ext}`));
-    if (!runtimeConfigFile) return false;
-    try {
-        const content = await fs.readFile(runtimeConfigFile, 'utf-8');
-        return /framework\s*:\s*['"]tanstack['"]/.test(content);
-    } catch  {
-        return false;
+const LOCALE_PARAM_SEGMENTS = new Set([
+    ':lang',
+    ':locale',
+    ':language',
+    '$lang',
+    '$locale',
+    '$language'
+]);
+function paramsTypeForCanonicalPath(canonicalPath) {
+    const fields = [];
+    for (const segment of canonicalPath.split('/'))if (segment) {
+        if ('*' === segment || '$' === segment) {
+            fields.push("'_splat'?: string");
+            continue;
+        }
+        if (segment.startsWith('{-$') && segment.endsWith('}')) {
+            fields.push(`${JSON.stringify(segment.slice(3, -1))}?: string`);
+            continue;
+        }
+        if (segment.startsWith('$')) {
+            fields.push(`${JSON.stringify(segment.slice(1))}: string`);
+            continue;
+        }
+        if (segment.startsWith(':')) {
+            const optional = segment.endsWith('?');
+            const name = segment.slice(1, optional ? void 0 : segment.length);
+            fields.push(`${JSON.stringify(optional ? name.slice(0, -1) : name)}${optional ? '?' : ''}: string`);
+        }
     }
+    return fields.length > 0 ? `{ ${fields.join('; ')} }` : 'Record<string, never>';
+}
+function collectCanonicalRoutesForEntry(routes, options = {}) {
+    const { localeParamHeuristic = true } = options;
+    const canonicalParams = new Map();
+    let hasI18nSurface = false;
+    const normalizeJoined = (joined)=>{
+        const collapsed = joined.replace(/\/+/g, '/');
+        const withLeading = collapsed.startsWith('/') ? collapsed : `/${collapsed}`;
+        return withLeading.length > 1 ? withLeading.replace(/\/+$/, '') : withLeading;
+    };
+    const record = (canonicalPath)=>{
+        const normalized = normalizeJoined(canonicalPath || '/');
+        const key = toTanstackPath(normalized);
+        if (!canonicalParams.has(key)) canonicalParams.set(key, paramsTypeForCanonicalPath(normalized));
+    };
+    const visit = (route, parentPath)=>{
+        let currentPath = parentPath;
+        if ('string' == typeof route.modernCanonicalPath) {
+            hasI18nSurface = true;
+            currentPath = normalizeJoined(route.modernCanonicalPath);
+        } else if ('string' == typeof route.path && route.path.length > 0) {
+            const segments = route.path.replace(/\[(.+?)\]/g, ':$1').split('/').filter(Boolean);
+            if (localeParamHeuristic && '' === parentPath && LOCALE_PARAM_SEGMENTS.has(segments[0])) {
+                hasI18nSurface = true;
+                segments.shift();
+            }
+            currentPath = segments.length ? normalizeJoined(`${parentPath}/${segments.join('/')}`) : parentPath;
+        }
+        const children = route.children;
+        if (children && children.length > 0) {
+            for (const child of children)visit(child, currentPath);
+            return;
+        }
+        record(currentPath || '/');
+    };
+    const rootModern = routes.find((route)=>route.isRoot);
+    const topLevel = rootModern ? rootModern.children ?? [] : routes;
+    for (const route of topLevel)visit(route, '');
+    if (!hasI18nSurface || 0 === canonicalParams.size) return null;
+    return Object.fromEntries([
+        ...canonicalParams.entries()
+    ].sort(([a], [b])=>a.localeCompare(b)));
 }
 async function generateTanstackRouterTypesSourceForEntry(opts) {
     const { appContext, entryName, generatedDirName = 'modern-tanstack', routes } = opts;
@@ -96,12 +147,30 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
     const imports = [];
     const statements = [];
     const loaderImportMap = new Map();
+    const componentImportMap = new Map();
     const searchContractImportMap = new Map();
     const usedRouteVarNames = new Set();
     let loaderIndex = 0;
+    let componentIndex = 0;
     let validateSearchIndex = 0;
     let loaderDepsIndex = 0;
     let routeIndex = 0;
+    const getImportNameForComponent = (componentPath)=>{
+        if ('string' != typeof componentPath || 0 === componentPath.length) return Promise.resolve(null);
+        let pendingImportName = componentImportMap.get(componentPath);
+        if (!pendingImportName) {
+            pendingImportName = (async ()=>{
+                const resolvedNoExt = await resolveRouteModuleNoExt(componentPath);
+                if (!resolvedNoExt) return null;
+                const relImport = normalizeRelativeImport(path.relative(outDir, resolvedNoExt));
+                const componentName = `component_${componentIndex++}`;
+                imports.push(`import ${componentName} from ${quote(relImport)};`);
+                return componentName;
+            })();
+            componentImportMap.set(componentPath, pendingImportName);
+        }
+        return pendingImportName;
+    };
     const resolveRouteModuleNoExt = async (aliasedNoExtPath)=>{
         const prefix = `${appContext.internalSrcAlias}/`;
         let absNoExt;
@@ -176,6 +245,8 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         const routeOpts = [
             `getParentRoute: () => ${parentVar},`
         ];
+        const componentName = await getImportNameForComponent(route._component);
+        if (componentName) routeOpts.push(`component: ${componentName},`);
         if (isPathlessLayout(route)) {
             const id = route.id;
             routeOpts.push(`id: ${quote(id || 'pathless')},`);
@@ -218,6 +289,8 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             route
         })));
     const rootOpts = [];
+    const rootComponentName = await getImportNameForComponent(rootModern?._component);
+    if (rootComponentName) rootOpts.push(`component: ${rootComponentName},`);
     if (rootLoaderName) rootOpts.push(`loader: modernLoaderToTanstack({ hasSplat: false }, ${rootLoaderName}),`);
     if (rootValidateSearchName) rootOpts.push(`validateSearch: ${rootValidateSearchName},`);
     if (rootLoaderDepsName) rootOpts.push(`loaderDeps: ${rootLoaderDepsName},`);
@@ -226,178 +299,15 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
 
 import {
   createMemoryHistory,
-  modernTanstackRouterFastDefaults,
   createRootRouteWithContext,
   createRoute,
   createRouter,
-  notFound,
-  redirect,
+  createRouteStaticData,
+  type ModernRouterContext,
+  modernLoaderToTanstack,
+  modernTanstackRouterFastDefaults,
 } from '@modern-js/plugin-tanstack/runtime';
 
-type ModernRouterContext = {
-  request?: Request;
-  requestContext?: unknown;
-};
-
-function isResponse(value: unknown): value is Response {
-  return (
-    value != null &&
-    typeof value === 'object' &&
-    typeof (value as any).status === 'number' &&
-    typeof (value as any).headers === 'object'
-  );
-}
-
-const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
-function isRedirectResponse(res: Response) {
-  return redirectStatusCodes.has(res.status);
-}
-
-function throwTanstackRedirect(location: string) {
-  const target = location.length > 0 ? location : '/';
-  try {
-    void new URL(target);
-    throw redirect({ href: target });
-  } catch {
-    throw redirect({ to: target });
-  }
-}
-
-function mapParamsForModernLoader(params: Record<string, string>, hasSplat: boolean) {
-  if (!hasSplat) {
-    return params;
-  }
-
-  const { _splat, ...rest } = params as any;
-  if (typeof _splat !== 'undefined') {
-    return { ...rest, '*': _splat };
-  }
-  return rest;
-}
-
-function createRouteStaticData(opts: {
-  modernRouteId?: string;
-  modernRouteAction?: unknown;
-  modernRouteLoader?: unknown;
-}) {
-  const staticData: {
-    modernRouteId?: string;
-    modernRouteAction?: unknown;
-    modernRouteLoader?: unknown;
-  } = {};
-
-  if (typeof opts.modernRouteId === 'string' && opts.modernRouteId.length > 0) {
-    staticData.modernRouteId = opts.modernRouteId;
-  }
-
-  if (typeof opts.modernRouteLoader !== 'undefined') {
-    staticData.modernRouteLoader = opts.modernRouteLoader;
-  }
-
-  if (typeof opts.modernRouteAction !== 'undefined') {
-    staticData.modernRouteAction = opts.modernRouteAction;
-  }
-
-  return staticData;
-}
-
-function getLoaderSignal(ctx: any): AbortSignal {
-  const abortSignal = ctx?.abortController?.signal;
-  if (abortSignal instanceof AbortSignal) {
-    return abortSignal;
-  }
-  if (ctx?.signal instanceof AbortSignal) {
-    return ctx.signal;
-  }
-  return new AbortController().signal;
-}
-
-function getLoaderHref(ctx: any): string {
-  if (typeof ctx?.location === 'string') {
-    return ctx.location;
-  }
-
-  const publicHref = ctx?.location?.publicHref;
-  if (typeof publicHref === 'string') {
-    return publicHref;
-  }
-
-  const href = ctx?.location?.href;
-  if (typeof href === 'string') {
-    return href;
-  }
-
-  const urlHref = ctx?.location?.url?.href;
-  return typeof urlHref === 'string' ? urlHref : '';
-}
-
-function getLoaderParams(ctx: any): Record<string, string> {
-  return typeof ctx?.params === 'object' && ctx.params !== null ? ctx.params : {};
-}
-
-function handleModernLoaderResult<LoaderResult>(result: LoaderResult): LoaderResult {
-  if (isResponse(result)) {
-    if (isRedirectResponse(result)) {
-      const location = result.headers.get('Location') ?? '/';
-      throwTanstackRedirect(location);
-    }
-    if (result.status === 404) {
-      throw notFound();
-    }
-  }
-
-  return result;
-}
-
-function handleModernLoaderError(err: unknown): never {
-  if (isResponse(err)) {
-    if (isRedirectResponse(err)) {
-      const location = err.headers.get('Location') ?? '/';
-      throwTanstackRedirect(location);
-    }
-    if (err.status === 404) {
-      throw notFound();
-    }
-  }
-
-  throw err;
-}
-
-function modernLoaderToTanstack<TLoader extends (args: any) => any>(
-  opts: { hasSplat: boolean },
-  modernLoader: TLoader,
-) {
-  type LoaderResult = Awaited<ReturnType<TLoader>>;
-
-  return (ctx: any): Promise<LoaderResult> => {
-    try {
-      const signal = getLoaderSignal(ctx);
-      const baseRequest: Request | undefined =
-        ctx?.context?.request instanceof Request ? ctx.context.request : undefined;
-
-      const href = getLoaderHref(ctx);
-
-      const request = baseRequest !== undefined
-        ? new Request(baseRequest, { signal })
-        : new Request(href, { signal });
-
-      const params = mapParamsForModernLoader(getLoaderParams(ctx), opts.hasSplat);
-
-      return Promise.resolve(
-        (modernLoader as any)({
-          request,
-          params,
-          context: ctx?.context?.requestContext,
-        }),
-      )
-        .then((result: LoaderResult) => handleModernLoaderResult(result))
-        .catch(handleModernLoaderError);
-    } catch (err) {
-      handleModernLoaderError(err);
-    }
-  };
-}
-
 ${imports.join('\n')}
 
 export const rootRoute = createRootRouteWithContext<ModernRouterContext>()({
@@ -426,4 +336,4 @@ export const router = createRouter({
         routerGenTs
     };
 }
-export { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled };
+export { collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry };

package/dist/esm/runtime/hooks.mjs

@@ -1,8 +1 @@
-import { createSyncHook } from "@modern-js/plugin";
-const modifyRoutes = createSyncHook();
-const onBeforeCreateRoutes = createSyncHook();
-const onBeforeCreateRouter = createSyncHook();
-const onAfterCreateRouter = createSyncHook();
-const onBeforeHydrateRouter = createSyncHook();
-const onAfterHydrateRouter = createSyncHook();
-export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter };
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, routerProviderRegistryHooks } from "@modern-js/runtime/context";

package/dist/esm/runtime/hydrationBoundary.mjs

@@ -1,9 +1,10 @@
 import { jsx } from "react/jsx-runtime";
 import { Suspense } from "react";
 function wrapTanstackSsrHydrationBoundary(routerContent, shouldWrap) {
-    return shouldWrap ? /*#__PURE__*/ jsx(Suspense, {
+    if (shouldWrap) return /*#__PURE__*/ jsx(Suspense, {
         fallback: null,
         children: routerContent
-    }) : routerContent;
+    });
+    return routerContent;
 }
 export { wrapTanstackSsrHydrationBoundary };

package/dist/esm/runtime/index.mjs

@@ -1,7 +1,9 @@
+import "./register.mjs";
 export * from "@tanstack/react-router";
-export { Outlet, useLocation, useMatch, useMatches, useNavigate, useRouter } from "@tanstack/react-router";
 export { Form, RouteActionResponseError, useFetcher } from "./dataMutation.mjs";
+export { createRouteStaticData, isAbsoluteUrl, modernLoaderToTanstack, throwTanstackRedirect } from "./loaderBridge.mjs";
+export { Outlet } from "./outlet.mjs";
 export { tanstackRouterPlugin as default, tanstackRouterPlugin } from "./plugin.mjs";
 export { Link, NavLink } from "./prefetchLink.mjs";
-export { CompositeComponent } from "./rsc/client.mjs";
+export { getTanstackRouterState } from "./state.mjs";
 export { getModernTanstackRouterFastDefaults, modernTanstackRouterFastDefaults } from "./types.mjs";

package/dist/esm/runtime/lifecycle.mjs

@@ -1,82 +1 @@
-function toHydrationScripts(state) {
-    if (state.hydrationScripts?.length) return state.hydrationScripts;
-    return state.hydrationScript ? [
-        state.hydrationScript
-    ] : void 0;
-}
-function getMatchedRouteIdsFromMatches(matches) {
-    const routeIds = matches?.map((match)=>match.assetRouteId ?? match.routeId).filter((routeId)=>'string' == typeof routeId);
-    return routeIds?.length ? routeIds : void 0;
-}
-function createRouterServerSnapshot(state) {
-    const hydrationScripts = toHydrationScripts(state);
-    const matchedRouteIds = state.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
-    return {
-        ...state,
-        ...hydrationScripts?.length ? {
-            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
-            hydrationScripts
-        } : {},
-        ...matchedRouteIds ? {
-            matchedRouteIds
-        } : {}
-    };
-}
-function createRouterRuntimeState(state) {
-    const hasSnapshotState = Boolean(state.serverSnapshot) || Boolean(state.hydrationScript) || Boolean(state.hydrationScripts?.length) || Boolean(state.matchedRouteIds?.length) || Boolean(state.matches?.length);
-    const serverSnapshot = state.serverSnapshot ? createRouterServerSnapshot({
-        ...state.serverSnapshot,
-        framework: state.serverSnapshot.framework ?? state.framework,
-        basename: state.serverSnapshot.basename ?? state.basename,
-        hydrationScript: state.serverSnapshot.hydrationScript ?? state.hydrationScript,
-        hydrationScripts: state.serverSnapshot.hydrationScripts ?? state.hydrationScripts,
-        matchedRouteIds: state.serverSnapshot.matchedRouteIds ?? state.matchedRouteIds,
-        matches: state.serverSnapshot.matches ?? state.matches
-    }) : hasSnapshotState ? createRouterServerSnapshot({
-        framework: state.framework,
-        basename: state.basename,
-        hydrationScript: state.hydrationScript,
-        hydrationScripts: state.hydrationScripts,
-        matchedRouteIds: state.matchedRouteIds,
-        matches: state.matches
-    }) : void 0;
-    const hydrationScripts = toHydrationScripts({
-        hydrationScript: state.hydrationScript ?? serverSnapshot?.hydrationScript,
-        hydrationScripts: state.hydrationScripts ?? serverSnapshot?.hydrationScripts
-    });
-    const matchedRouteIds = state.matchedRouteIds ?? serverSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
-    return {
-        ...state,
-        ...hydrationScripts?.length ? {
-            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
-            hydrationScripts
-        } : {},
-        ...matchedRouteIds ? {
-            matchedRouteIds
-        } : {},
-        ...serverSnapshot ? {
-            serverSnapshot
-        } : {}
-    };
-}
-function applyRouterRuntimeState(runtimeContext, state) {
-    const normalized = createRouterRuntimeState(state);
-    const mutableRuntimeContext = runtimeContext;
-    mutableRuntimeContext.routerFramework = normalized.framework;
-    mutableRuntimeContext.routerInstance = normalized.instance;
-    mutableRuntimeContext.routerHydrationScript = normalized.hydrationScript;
-    mutableRuntimeContext.routerMatchedRouteIds = normalized.matchedRouteIds;
-    mutableRuntimeContext.routerRuntime = normalized;
-    if (normalized.serverSnapshot) mutableRuntimeContext.routerServerSnapshot = normalized.serverSnapshot;
-    return runtimeContext;
-}
-function applyRouterServerPrepareResult(runtimeContext, result) {
-    const state = createRouterRuntimeState({
-        ...result.state,
-        cleanup: result.cleanup ?? result.state.cleanup,
-        serverSnapshot: result.snapshot ?? result.state.serverSnapshot
-    });
-    applyRouterRuntimeState(runtimeContext, state);
-    return runtimeContext;
-}
-export { applyRouterRuntimeState, applyRouterServerPrepareResult, createRouterRuntimeState, createRouterServerSnapshot };
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, createRouterRuntimeState, createRouterServerSnapshot, getRouterRuntimeState, getRouterServerSnapshot } from "@modern-js/runtime/context";

package/dist/esm/runtime/loaderBridge.mjs

@@ -0,0 +1,114 @@
+import { notFound, redirect } from "@tanstack/react-router";
+function isResponse(value) {
+    const record = value;
+    return null != record && 'object' == typeof record && 'number' == typeof record.status && 'object' == typeof record.headers;
+}
+const redirectStatusCodes = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+function isRedirectResponse(res) {
+    return redirectStatusCodes.has(res.status);
+}
+function isTanstackRedirect(value) {
+    return isResponse(value) && 'object' == typeof value.options;
+}
+function isAbsoluteUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function throwTanstackRedirect(location) {
+    const target = location || '/';
+    if (isAbsoluteUrl(target)) throw redirect({
+        href: target
+    });
+    throw redirect({
+        to: target
+    });
+}
+function mapSplatParamsForModernLoader(params, hasSplat) {
+    if (!hasSplat) return params;
+    const { _splat, ...rest } = params;
+    if (void 0 !== _splat) return {
+        ...rest,
+        '*': _splat
+    };
+    return rest;
+}
+function createRouteStaticData(opts) {
+    const staticData = {};
+    if ('string' == typeof opts.modernRouteId && opts.modernRouteId.length > 0) staticData.modernRouteId = opts.modernRouteId;
+    if (void 0 !== opts.modernRouteLoader) staticData.modernRouteLoader = opts.modernRouteLoader;
+    if (void 0 !== opts.modernRouteAction) staticData.modernRouteAction = opts.modernRouteAction;
+    return staticData;
+}
+function getLoaderSignal(ctx) {
+    const abortSignal = ctx?.abortController?.signal;
+    if (abortSignal instanceof AbortSignal) return abortSignal;
+    if (ctx?.signal instanceof AbortSignal) return ctx.signal;
+    return new AbortController().signal;
+}
+function getLoaderHref(ctx) {
+    if ('string' == typeof ctx?.location) return ctx.location;
+    const publicHref = ctx?.location?.publicHref;
+    if ('string' == typeof publicHref) return publicHref;
+    const href = ctx?.location?.href;
+    if ('string' == typeof href) return href;
+    const urlHref = ctx?.location?.url?.href;
+    return 'string' == typeof urlHref ? urlHref : '';
+}
+function getLoaderParams(ctx) {
+    return 'object' == typeof ctx?.params && null !== ctx.params ? ctx.params : {};
+}
+function handleModernLoaderResult(result) {
+    if (isResponse(result)) {
+        if (isRedirectResponse(result)) {
+            const location = result.headers.get('Location') ?? '/';
+            throwTanstackRedirect(location);
+        }
+        if (404 === result.status) throw notFound();
+    }
+    return result;
+}
+function handleModernLoaderError(err) {
+    if (isResponse(err)) {
+        if (isTanstackRedirect(err)) throw err;
+        if (isRedirectResponse(err)) {
+            const location = err.headers.get('Location') ?? '/';
+            throwTanstackRedirect(location);
+        }
+        if (404 === err.status) throw notFound();
+    }
+    throw err;
+}
+function modernLoaderToTanstack(opts, modernLoader) {
+    return (rawCtx)=>{
+        const ctx = rawCtx;
+        try {
+            const signal = getLoaderSignal(ctx);
+            const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
+            const href = getLoaderHref(ctx);
+            const request = void 0 !== baseRequest ? new Request(baseRequest, {
+                signal
+            }) : new Request(href, {
+                signal
+            });
+            const params = mapSplatParamsForModernLoader(getLoaderParams(ctx), opts.hasSplat);
+            return Promise.resolve(modernLoader({
+                request,
+                params,
+                context: ctx?.context?.requestContext
+            })).then((result)=>handleModernLoaderResult(result)).catch(handleModernLoaderError);
+        } catch (err) {
+            handleModernLoaderError(err);
+        }
+    };
+}
+export { createRouteStaticData, isAbsoluteUrl, isRedirectResponse, isResponse, isTanstackRedirect, mapSplatParamsForModernLoader, modernLoaderToTanstack, throwTanstackRedirect };

package/dist/esm/runtime/outlet.mjs

@@ -0,0 +1,17 @@
+import { jsx } from "react/jsx-runtime";
+import { Outlet } from "@tanstack/react-router";
+import { createElement, memo } from "react";
+const outlet_Outlet = /*#__PURE__*/ memo(function() {
+    return /*#__PURE__*/ jsx(Outlet, {});
+});
+function withModernRouteMatchContext(component, _routeId) {
+    if (null == component) return component;
+    const Component = component;
+    const WrappedRouteComponent = (props)=>/*#__PURE__*/ createElement(Component, props);
+    const preloadable = component;
+    if ('function' == typeof preloadable.load) WrappedRouteComponent.load = preloadable.load.bind(preloadable);
+    if ('function' == typeof preloadable.preload) WrappedRouteComponent.preload = preloadable.preload.bind(preloadable);
+    else if ('function' == typeof preloadable.load) WrappedRouteComponent.preload = WrappedRouteComponent.load;
+    return WrappedRouteComponent;
+}
+export { outlet_Outlet as Outlet, withModernRouteMatchContext };