@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.36 → 3.5.0-ultramodern.38

package/src/runtime/register.ts

@@ -1,5 +1,5 @@
 /**
- * Registers the TanStack router provider with the @modern-js/runtime router
+ * Registers TanStack router provider with the @modern-js/runtime router
  * provider registry. Importing '@modern-js/plugin-tanstack/runtime' is enough
  * to make `runtime.router.framework: 'tanstack'` resolvable by the built-in
  * router runtime plugin.
@@ -12,47 +12,15 @@ import {
   type RouterProviderPlugin,
   registerRouterProvider,
 } from '@modern-js/runtime/context';
-import { Form, RouteActionResponseError, useFetcher } from './dataMutation';
-import { Outlet } from './outlet';
 import { tanstackRouterPlugin } from './plugin';
-import { Link, NavLink } from './prefetchLink';
 
-// The TanStack runtime plugin types its API against its own hook registry,
+// TanStack runtime plugin types its API against its own hook registry,
 // while the provider contract is typed against the built-in router hook
-// registry of @modern-js/runtime. The two are runtime-compatible (the
+// registry from @modern-js/runtime. The two are runtime-compatible (the
 // built-in router plugin registers the hooks and forwards its API to the
-// resolved provider), but nominally distinct — hence the explicit adapter
-// cast at this single boundary.
+// resolved provider), but nominally distinct, so keep an explicit adapter
+// cast as the single boundary.
 const tanstackRouterProviderFactory: RouterProviderFactory = userConfig =>
   tanstackRouterPlugin(userConfig) as unknown as RouterProviderPlugin;
 
 registerRouterProvider('tanstack', tanstackRouterProviderFactory);
-
-/**
- * Compatibility bindings for the deprecated `@modern-js/runtime/tanstack-router`
- * alias. `@modern-js/runtime` cannot depend on this package (the dependency
- * direction is plugin-tanstack -> runtime), so the alias resolves the
- * Modern.js specific bindings through this `Symbol.for` slot at use time.
- *
- * `??=` keeps the first copy: when Module Federation evaluates a second
- * bundled copy of this module, both copies are functionally identical and the
- * established registration wins (mirroring the router-provider registry).
- */
-const COMPAT_BINDINGS_SLOT: unique symbol = Symbol.for(
-  '@modern-js/plugin-tanstack:runtime-compat-bindings',
-);
-
-export const tanstackRouterCompatBindings = {
-  Form,
-  Link,
-  NavLink,
-  Outlet,
-  RouteActionResponseError,
-  useFetcher,
-};
-
-(
-  globalThis as {
-    [COMPAT_BINDINGS_SLOT]?: typeof tanstackRouterCompatBindings;
-  }
-)[COMPAT_BINDINGS_SLOT] ??= tanstackRouterCompatBindings;

package/src/runtime/routeTree/types.ts

@@ -8,7 +8,7 @@ import type {
 
 export type RouteParams = Record<string, string>;
 
-export type ModernLoader = (args: {
+type ModernLoader = (args: {
   request: Request;
   params: RouteParams;
   context?: unknown;

package/src/runtime/rsc/ReplayableStream.ts

@@ -1,5 +1,5 @@
 // @effect-diagnostics asyncFunction:off newPromise:off strictBooleanExpressions:off
-export interface ReplayableStreamOptions {
+interface ReplayableStreamOptions {
   signal?: AbortSignal;
 }
 
@@ -8,7 +8,7 @@ type Waiter = {
   resolve: () => void;
 };
 
-export const REPLAYABLE_STREAM_MARKER = Symbol.for(
+const REPLAYABLE_STREAM_MARKER = Symbol.for(
   'modern.tanstack.rsc.ReplayableStream',
 );
 

package/src/runtime/rsc/SlotContext.tsx

@@ -3,7 +3,7 @@
 import type React from 'react';
 import { createContext, use } from 'react';
 
-export type SlotImplementations = Record<string, unknown>;
+type SlotImplementations = Record<string, unknown>;
 
 const SlotContext = createContext<{
   implementations: SlotImplementations;

package/src/runtime/rsc/payloadFetch.ts

@@ -1,14 +1,17 @@
 // @effect-diagnostics asyncFunction:off globalFetch:off processEnv:off strictBooleanExpressions:off
 import type { ServerPayload } from '@modern-js/runtime/context';
 import { notFound, redirect } from '@tanstack/react-router';
+import { isAbsoluteUrl } from '../shared/isAbsoluteUrl';
 import { reviveTanstackRscFlightValues } from './flightSerialization';
 
+export { isAbsoluteUrl };
+
 type PayloadDecoder = (stream: ReadableStream<Uint8Array>) => Promise<unknown>;
 
 export const payloadFetchCache = new Map<string, Promise<ServerPayload>>();
 let payloadDecoder: PayloadDecoder | undefined;
 
-export async function decodePayload(stream: ReadableStream<Uint8Array>) {
+async function decodePayload(stream: ReadableStream<Uint8Array>) {
   if (payloadDecoder) {
     return reviveTanstackRscFlightValues(await payloadDecoder(stream));
   }
@@ -19,7 +22,7 @@ export async function decodePayload(stream: ReadableStream<Uint8Array>) {
   );
 }
 
-export function isServerPayload(value: unknown): value is ServerPayload {
+function isServerPayload(value: unknown): value is ServerPayload {
   return (
     Boolean(value) &&
     typeof value === 'object' &&
@@ -38,15 +41,6 @@ export function createPayloadFetchKey(request: Request) {
   ]);
 }
 
-export function isAbsoluteUrl(value: string) {
-  try {
-    void new URL(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 export async function fetchTanstackRscPayload(request: Request) {
   const headers = new Headers(request.headers);
   headers.set('x-rsc-tree', 'true');

package/src/runtime/rsc/payloadRoutes.ts

@@ -1,7 +1,7 @@
 // @effect-diagnostics asyncFunction:off globalFetch:off processEnv:off strictBooleanExpressions:off
 import type { PayloadRoute, ServerPayload } from '@modern-js/runtime/context';
 
-export type RouterStaticData = {
+type RouterStaticData = {
   modernRouteAction?: unknown;
   modernRouteHandle?: unknown;
   modernRouteHasAction?: unknown;
@@ -11,7 +11,7 @@ export type RouterStaticData = {
   modernRouteIsClientComponent?: unknown;
 };
 
-export type RouterRouteLike = {
+type RouterRouteLike = {
   id?: unknown;
   options?: {
     index?: unknown;
@@ -40,7 +40,7 @@ export type TanstackPayloadRouterLike = {
   };
 };
 
-export function toPlainRecord(value: unknown): Record<string, unknown> {
+function toPlainRecord(value: unknown): Record<string, unknown> {
   if (!value || typeof value !== 'object') {
     return {};
   }
@@ -73,16 +73,16 @@ export function getRouteId(match: RouterMatchLike) {
   return typeof routeId === 'string' ? routeId : undefined;
 }
 
-export function getRouteStaticData(match: RouterMatchLike) {
+function getRouteStaticData(match: RouterMatchLike) {
   return match.route?.options?.staticData || {};
 }
 
-export function getRouteParentId(match: RouterMatchLike) {
+function getRouteParentId(match: RouterMatchLike) {
   const parentId = match.route?.parentRoute?.id;
   return typeof parentId === 'string' ? parentId : undefined;
 }
 
-export function toRoutePath(match: RouterMatchLike) {
+function toRoutePath(match: RouterMatchLike) {
   const path = match.route?.options?.path;
   return typeof path === 'string' ? path : undefined;
 }

package/src/runtime/rsc/shared.ts

@@ -35,7 +35,7 @@ export function EmptyFallback() {
   return null;
 }
 
-export function selectTreePath(tree: unknown, path: string[]) {
+function selectTreePath(tree: unknown, path: string[]) {
   let current = tree;
   for (const key of path) {
     if (current === null || typeof current !== 'object') {

package/src/runtime/shared/isAbsoluteUrl.ts

@@ -0,0 +1,8 @@
+export function isAbsoluteUrl(value: string): boolean {
+  try {
+    void new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/runtime/ssrTypes.ts

@@ -23,14 +23,14 @@ export type RouterMatchWithError = {
   routeId?: unknown;
 };
 
-export type RouterRouteOptions = {
+type RouterRouteOptions = {
   component?: unknown;
   errorComponent?: unknown;
   notFoundComponent?: unknown;
   pendingComponent?: unknown;
 };
 
-export type RouterRouteWithOptions = {
+type RouterRouteWithOptions = {
   options?: RouterRouteOptions;
 };
 

package/src/runtime/submitAction.ts

@@ -31,14 +31,21 @@ type RouteLoader = (args: {
   context?: unknown;
 }) => Promise<unknown> | unknown;
 
+type RouterBuildLocationOptions = Parameters<AnyRouter['buildLocation']>[0];
+type RouterBuiltLocation = ReturnType<AnyRouter['buildLocation']> & {
+  pathname: string;
+};
+type RouterParsedLocation = Parameters<AnyRouter['getParsedLocationHref']>[0];
+type RouterNavigateOptions = Parameters<AnyRouter['navigate']>[0];
+
 function resolveRouteHandlers(router: AnyRouter, actionTo: string) {
   const builtLocation = router.buildLocation({
-    to: actionTo as any,
-  } as any);
-  const href = router.getParsedLocationHref(builtLocation as any);
-  const matchedRoutes = router.getMatchedRoutes(
-    (builtLocation as any).pathname,
+    to: actionTo,
+  } as RouterBuildLocationOptions) as RouterBuiltLocation;
+  const href = router.getParsedLocationHref(
+    builtLocation as RouterParsedLocation,
   );
+  const matchedRoutes = router.getMatchedRoutes(builtLocation.pathname);
   const routeStaticData = matchedRoutes.foundRoute?.options?.staticData as
     | Record<string, unknown>
     | undefined;
@@ -118,8 +125,8 @@ export async function submitRouteAction({
           result.headers.get('Location');
         if (redirectTo || isRedirectResponse(result)) {
           await router.navigate({
-            to: (redirectTo || '/') as any,
-          } as any);
+            to: redirectTo || '/',
+          } as RouterNavigateOptions);
           return parseResponseData(result);
         }
         return parseResponseResultOrThrow(result);
@@ -130,7 +137,7 @@ export async function submitRouteAction({
 
     await router.navigate({
       href: `${requestUrl.pathname}${requestUrl.search}${requestUrl.hash}`,
-    } as any);
+    } as RouterNavigateOptions);
     return;
   }
 
@@ -175,8 +182,8 @@ export async function submitRouteAction({
       result.headers.get('Location');
     if (redirectTo || isRedirectResponse(result)) {
       await router.navigate({
-        to: (redirectTo || '/') as any,
-      } as any);
+        to: redirectTo || '/',
+      } as RouterNavigateOptions);
       return parseResponseData(result);
     }
 

package/src/runtime/types.ts

@@ -1,22 +1,15 @@
-import type { ModernRoute, RouterFramework } from '@modern-js/runtime/context';
+import type { ModernRoute } from '@modern-js/runtime/context';
 import type { RouteObject } from '@modern-js/runtime-utils/router';
 import type React from 'react';
 
 export type {
-  BuiltInRouterFramework,
-  InternalRouterRuntimeState,
   InternalRouterServerSnapshot,
-  LoaderFunction,
-  LoaderFunctionArgs,
   ModernRoute,
   RouterFramework,
-  RouterRouteMatchSnapshot,
-  RouterServerPrepareResult,
 } from '@modern-js/runtime/context';
 
 /** TanStack-specific router config. */
 export type RouterConfig = {
-  framework?: RouterFramework;
   routesConfig: {
     globalApp?: React.ComponentType<any>;
     routes?: ModernRoute[];

package/tests/router/register.test.ts

@@ -1,46 +1,8 @@
 import { resolveRouterProvider } from '@modern-js/runtime/context';
-import {
-  Form,
-  Link,
-  NavLink,
-  Outlet,
-  RouteActionResponseError,
-  useFetcher,
-} from '../../src/runtime';
-import { tanstackRouterCompatBindings } from '../../src/runtime/register';
-
-const COMPAT_BINDINGS_SLOT = Symbol.for(
-  '@modern-js/plugin-tanstack:runtime-compat-bindings',
-);
+import '../../src/runtime/register';
 
 describe("'@modern-js/plugin-tanstack/runtime' import side effects", () => {
   it('registers the tanstack router provider', () => {
     expect(typeof resolveRouterProvider('tanstack')).toBe('function');
   });
-
-  it("publishes the compat bindings consumed by '@modern-js/runtime/tanstack-router'", () => {
-    const bindings = (globalThis as Record<symbol, unknown>)[
-      COMPAT_BINDINGS_SLOT
-    ] as typeof tanstackRouterCompatBindings;
-
-    expect(bindings).toBeDefined();
-    expect(bindings).toBe(tanstackRouterCompatBindings);
-    expect(bindings.Form).toBe(Form);
-    expect(bindings.Link).toBe(Link);
-    expect(bindings.NavLink).toBe(NavLink);
-    expect(bindings.Outlet).toBe(Outlet);
-    expect(bindings.RouteActionResponseError).toBe(RouteActionResponseError);
-    expect(bindings.useFetcher).toBe(useFetcher);
-  });
-
-  it('keeps the first published bindings when a duplicate module copy evaluates', () => {
-    // Simulates a Module Federation remote evaluating its own copy of
-    // register.ts: `??=` must keep the established bindings.
-    const host = globalThis as Record<symbol, unknown>;
-    const established = host[COMPAT_BINDINGS_SLOT];
-    expect(established).toBeDefined();
-
-    host[COMPAT_BINDINGS_SLOT] ??= { duplicate: true };
-    expect(host[COMPAT_BINDINGS_SLOT]).toBe(established);
-  });
 });