@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.12 → 3.2.0-ultramodern.121

package/src/runtime/rsc/payloadRouter.ts

@@ -1,5 +1,6 @@
-// @effect-diagnostics asyncFunction:off globalFetch:off strictBooleanExpressions:off
+// @effect-diagnostics asyncFunction:off globalFetch:off processEnv:off strictBooleanExpressions:off
 import type { PayloadRoute, ServerPayload } from '@modern-js/runtime/context';
+import { isRouteErrorResponse } from '@modern-js/runtime-utils/router';
 import { notFound, redirect } from '@tanstack/react-router';
 
 type PayloadDecoder = (stream: ReadableStream<Uint8Array>) => Promise<unknown>;
@@ -103,6 +104,48 @@ function toPayloadRoute(match: RouterMatchLike): PayloadRoute | undefined {
   };
 }
 
+function shouldRedactServerError(status = 500) {
+  return (
+    status >= 500 &&
+    process.env.NODE_ENV !== 'development' &&
+    process.env.NODE_ENV !== 'test'
+  );
+}
+
+function serializePayloadError(error: unknown): unknown {
+  if (isRouteErrorResponse(error)) {
+    if (shouldRedactServerError(error.status)) {
+      return {
+        status: error.status,
+        statusText: 'Internal Server Error',
+        data: 'Unexpected Server Error',
+        __type: 'RouteErrorResponse',
+      };
+    }
+
+    return { ...error, __type: 'RouteErrorResponse' };
+  }
+
+  if (error instanceof Error) {
+    if (shouldRedactServerError()) {
+      return {
+        message: 'Unexpected Server Error',
+        stack: undefined,
+        __type: 'Error',
+      };
+    }
+
+    return {
+      message: error.message,
+      stack: error.stack,
+      __type: 'Error',
+      ...(error.name !== 'Error' ? { __subType: error.name } : {}),
+    };
+  }
+
+  return error;
+}
+
 export function createTanstackRscServerPayload(
   router: TanstackPayloadRouterLike,
   options: {
@@ -133,7 +176,7 @@ export function createTanstackRscServerPayload(
     }
 
     if (typeof match.error !== 'undefined') {
-      errors[payloadRoute.id] = match.error;
+      errors[payloadRoute.id] = serializePayloadError(match.error);
     }
   }
 

package/src/runtime/ssr-shim.d.ts

@@ -1,7 +1,5 @@
 declare module '@tanstack/react-router/ssr/client' {
-  export function RouterClient(props: {
-    router: unknown;
-  }): import('react').JSX.Element;
+  export function hydrate(router: unknown): Promise<unknown>;
 }
 
 declare module '@tanstack/react-router/ssr/server' {

package/src/runtime/state.ts

@@ -0,0 +1,29 @@
+import { getRouterRuntimeState } from '@modern-js/runtime/context';
+import type { AnyRouter } from '@tanstack/react-router';
+import type { InternalRouterRuntimeState } from './types';
+
+/**
+ * Router runtime state as published by the TanStack router provider into the
+ * runtime-context extension slot.
+ */
+export interface TanstackRouterState
+  extends Omit<InternalRouterRuntimeState, 'framework' | 'instance'> {
+  framework: 'tanstack';
+  instance?: AnyRouter;
+}
+
+/**
+ * Typed accessor for the TanStack router state stored on a Modern.js runtime
+ * context. Returns `undefined` when the active router provider is not
+ * TanStack (e.g. react-router) or no router has been created yet.
+ */
+export function getTanstackRouterState(
+  context: object,
+): TanstackRouterState | undefined {
+  const state = getRouterRuntimeState(context);
+  if (state === undefined || state.framework !== 'tanstack') {
+    return undefined;
+  }
+
+  return state as TanstackRouterState;
+}

package/src/runtime/types.ts

@@ -1,83 +1,49 @@
-import type { RequestContext } from '@modern-js/runtime-utils/node';
+import type {
+  RouterFramework,
+  // The router runtime state types are owned by @modern-js/runtime; they are
+  // imported through the `/context` seam instead of being copied here so
+  // upstream fixes propagate to this package automatically.
+} from '@modern-js/runtime/context';
 import type { RouteObject } from '@modern-js/runtime-utils/router';
 import type { NestedRoute, PageRoute } from '@modern-js/types';
 import type React from 'react';
 
-export type BuiltInRouterFramework = 'react-router' | 'tanstack';
-export type RouterFramework = BuiltInRouterFramework | (string & {});
-
+export type {
+  BuiltInRouterFramework,
+  InternalRouterRuntimeState,
+  InternalRouterServerSnapshot,
+  RouterFramework,
+  RouterRouteMatchSnapshot,
+  RouterServerPrepareResult,
+} from '@modern-js/runtime/context';
+
+/**
+ * TanStack-specific router config. Unlike the react-router provider config,
+ * this intentionally has no `oldVersion`/`future` fields — those are
+ * react-router-only knobs with no meaning here.
+ */
 export type RouterConfig = {
   framework?: RouterFramework;
   routesConfig: {
     globalApp?: React.ComponentType<any>;
     routes?: (NestedRoute | PageRoute)[];
   };
-  oldVersion?: boolean;
   serverBase?: string[];
   supportHtml5History?: boolean;
   basename?: string;
   createRoutes?: () => RouteObject[];
-  future?: Partial<{
-    v7_startTransition: boolean;
-  }>;
+  defaultStructuralSharing?: boolean;
   unstable_reloadOnURLMismatch?: boolean;
 };
 
-export interface RouterRouteMatchSnapshot {
-  routeId: string;
-  assetRouteId?: string;
-  pathname?: string;
-  params?: Record<string, string>;
-}
-
-export interface InternalRouterServerSnapshot {
-  framework?: RouterFramework;
-  basename?: string;
-  statusCode?: number;
-  errors?: Record<string, unknown>;
-  routerData?: {
-    loaderData?: Record<string, unknown>;
-    errors?: Record<string, unknown>;
-  };
-  hydrationScript?: string;
-  hydrationScripts?: string[];
-  matchedRouteIds?: string[];
-  matches?: RouterRouteMatchSnapshot[];
-}
-
-export interface InternalRouterRuntimeState {
-  framework: RouterFramework;
-  basename?: string;
-  instance?: unknown;
-  hydrationScript?: string;
-  hydrationScripts?: string[];
-  matchedRouteIds?: string[];
-  matches?: RouterRouteMatchSnapshot[];
-  serverSnapshot?: InternalRouterServerSnapshot;
-  cleanup?: () => void | Promise<void>;
-}
-
-export interface RouterServerPrepareResult {
-  state: InternalRouterRuntimeState;
-  snapshot?: InternalRouterServerSnapshot;
-  redirect?: Response;
-  cleanup?: () => void | Promise<void>;
-}
-
-interface DataFunctionArgs<D = any> {
-  request: Request;
-  params: Record<string, string>;
-  context?: D;
-}
-
-export type LoaderFunctionArgs<
-  P extends Record<string, unknown> = Record<string, unknown>,
-> = DataFunctionArgs<RequestContext<P>>;
-
-type DataFunctionValue = Response | NonNullable<unknown> | null;
-
-export type LoaderFunction = <
-  P extends Record<string, unknown> = Record<string, unknown>,
->(
-  args: LoaderFunctionArgs<P>,
-) => Promise<DataFunctionValue> | DataFunctionValue;
+export const modernTanstackRouterFastDefaults = {
+  defaultStructuralSharing: true,
+} as const;
+
+export const getModernTanstackRouterFastDefaults = (
+  config: Partial<Pick<RouterConfig, 'defaultStructuralSharing'>> = {},
+) => ({
+  defaultStructuralSharing:
+    config.defaultStructuralSharing ??
+    modernTanstackRouterFastDefaults.defaultStructuralSharing,
+});

package/src/runtime/utils.tsx

@@ -2,7 +2,6 @@
 import type { RouteObject } from '@modern-js/runtime-utils/router';
 import type { NestedRoute, PageRoute, SSRMode } from '@modern-js/types';
 import React from 'react';
-import { DefaultNotFound } from './DefaultNotFound';
 
 type RouterConfig = {
   routesConfig: {
@@ -106,11 +105,9 @@ export function getRouteObjects(
     }
   }
 
-  routeObjects.push({
-    path: '*',
-    element: <DefaultNotFound />,
-  });
-
+  // No synthetic `{ path: '*' }` 404 route here: TanStack Router handles
+  // not-found matches through the root route's `notFoundComponent`
+  // (see routeTree.ts), so the react-router style catch-all is unnecessary.
   return routeObjects;
 }