@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.0

package/dist/types-direct/runtime/plugin.d.ts

@@ -0,0 +1,17 @@
+import type { Plugin, RuntimePluginExtends } from '@modern-js/plugin';
+import type { RuntimePluginAPI } from '@modern-js/plugin/runtime';
+import { type TInternalRuntimeContext } from '@modern-js/runtime/context';
+import { type RouterExtendsHooks } from './hooks';
+import type { RouterConfig } from './types';
+type TanstackRouterRuntimeConfig = {
+    plugins?: TanstackRouterRuntimePlugin[];
+    router?: Partial<RouterConfig>;
+    [key: string]: unknown;
+};
+type TanstackRouterRuntimeExtends = Required<RuntimePluginExtends<TanstackRouterRuntimeConfig, TInternalRuntimeContext>> & {
+    extendHooks: RouterExtendsHooks;
+};
+type TanstackRouterPluginAPI = RuntimePluginAPI<TanstackRouterRuntimeExtends>;
+type TanstackRouterRuntimePlugin = Plugin<TanstackRouterPluginAPI, TInternalRuntimeContext>;
+export declare const tanstackRouterPlugin: (userConfig?: Partial<RouterConfig>) => TanstackRouterRuntimePlugin;
+export default tanstackRouterPlugin;

package/dist/types-direct/runtime/plugin.node.d.ts

@@ -0,0 +1,17 @@
+import type { Plugin, RuntimePluginExtends } from '@modern-js/plugin';
+import type { RuntimePluginAPI } from '@modern-js/plugin/runtime';
+import { type TInternalRuntimeContext } from '@modern-js/runtime/context';
+import { type RouterExtendsHooks } from './hooks';
+import type { RouterConfig } from './types';
+type TanstackRouterRuntimeConfig = {
+    plugins?: TanstackRouterRuntimePlugin[];
+    router?: Partial<RouterConfig>;
+    [key: string]: unknown;
+};
+type TanstackRouterRuntimeExtends = Required<RuntimePluginExtends<TanstackRouterRuntimeConfig, TInternalRuntimeContext>> & {
+    extendHooks: RouterExtendsHooks;
+};
+type TanstackRouterPluginAPI = RuntimePluginAPI<TanstackRouterRuntimeExtends>;
+type TanstackRouterRuntimePlugin = Plugin<TanstackRouterPluginAPI, TInternalRuntimeContext>;
+export declare const tanstackRouterPlugin: (userConfig?: Partial<RouterConfig>) => TanstackRouterRuntimePlugin;
+export default tanstackRouterPlugin;

package/dist/types-direct/runtime/prefetchLink.d.ts

@@ -0,0 +1,11 @@
+import { type AnyRouter, type LinkComponentProps, type RegisteredRouter } from '@tanstack/react-router';
+import type { ReactElement } from 'react';
+export type PrefetchBehavior = 'intent' | 'render' | 'viewport' | 'none';
+export type LinkProps<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkComponentProps<'a', TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    prefetch?: PrefetchBehavior;
+};
+export type NavLinkProps<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkProps<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>;
+type LinkComponent = <TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(props: LinkProps<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => ReactElement;
+export declare const Link: LinkComponent;
+export declare const NavLink: LinkComponent;
+export {};

package/dist/types-direct/runtime/routeTree.d.ts

@@ -0,0 +1,11 @@
+import type { RouteObject } from '@modern-js/runtime-utils/router';
+import type { NestedRoute, PageRoute } from '@modern-js/types';
+import type { AnyRouter, RootRoute as TanstackRootRoute } from '@tanstack/react-router';
+type ModernTanstackRootRoute = TanstackRootRoute;
+type RouteTreeOptions = {
+    rscPayloadRouter?: boolean;
+};
+export declare function createRouteTreeFromModernRoutes(routes: Array<NestedRoute | PageRoute>, options?: RouteTreeOptions): ModernTanstackRootRoute;
+export declare function createRouteTreeFromRouteObjects(routes: RouteObject[], options?: RouteTreeOptions): ModernTanstackRootRoute;
+export declare function getModernRouteIdsFromMatches(router: AnyRouter): string[];
+export {};

package/dist/types-direct/runtime/rsc/ClientSlot.d.ts

@@ -0,0 +1,5 @@
+import type React from 'react';
+export declare function ClientSlot({ args, slot }: {
+    args: unknown[];
+    slot: string;
+}): React.JSX.Element | null;

package/dist/types-direct/runtime/rsc/CompositeComponent.d.ts

@@ -0,0 +1,3 @@
+import type React from 'react';
+import { type AnyCompositeComponent, type CompositeComponentProps } from './symbols';
+export declare function CompositeComponent<TComp extends AnyCompositeComponent>(props: CompositeComponentProps<TComp>): React.JSX.Element;

package/dist/types-direct/runtime/rsc/ReplayableStream.d.ts

@@ -0,0 +1,24 @@
+export interface ReplayableStreamOptions {
+    signal?: AbortSignal;
+}
+export declare const REPLAYABLE_STREAM_MARKER: unique symbol;
+export declare class ReplayableStream<T = Uint8Array> {
+    private source;
+    private options;
+    readonly [REPLAYABLE_STREAM_MARKER] = true;
+    private chunks;
+    private done;
+    private error;
+    private waiter;
+    private released;
+    private reader;
+    private abortListener;
+    constructor(source: ReadableStream<T>, options?: ReplayableStreamOptions);
+    private start;
+    private detachAbortListener;
+    private notify;
+    private wait;
+    release(): void;
+    isReleased(): boolean;
+    createReplayStream(): ReadableStream<T>;
+}

package/dist/types-direct/runtime/rsc/RscNodeRenderer.d.ts

@@ -0,0 +1,5 @@
+import type React from 'react';
+import { type AnyRenderableServerComponent } from './symbols';
+export declare function RscNodeRenderer({ data, }: {
+    data: AnyRenderableServerComponent;
+}): React.JSX.Element;

package/dist/types-direct/runtime/rsc/SlotContext.d.ts

@@ -0,0 +1,11 @@
+import type React from 'react';
+export type SlotImplementations = Record<string, unknown>;
+export declare function useSlotContext(): {
+    implementations: SlotImplementations;
+    strict: boolean;
+} | null;
+export declare function SlotProvider({ children, implementations, strict, }: {
+    children?: React.ReactNode;
+    implementations: SlotImplementations;
+    strict?: boolean;
+}): React.JSX.Element;

package/dist/types-direct/runtime/rsc/client.d.ts

@@ -0,0 +1,11 @@
+import { CompositeComponent } from './CompositeComponent';
+import type { AnyCompositeComponent, RscSlotUsageEvent } from './symbols';
+export type { AnyCompositeComponent, AnyRenderableServerComponent, CompositeComponentProps, } from './symbols';
+export { CompositeComponent };
+type SerializedRsc = {
+    kind: 'renderable' | 'composite';
+    stream: ReadableStream<Uint8Array>;
+    slotUsagesStream?: ReadableStream<RscSlotUsageEvent>;
+};
+export declare function getTanstackRscSerializationAdapters(): import("@tanstack/router-core").SerializationAdapter<AnyCompositeComponent<Record<string, unknown>, import("react").ReactNode>, SerializedRsc, never>[];
+export declare const rscSerializationAdapter: typeof getTanstackRscSerializationAdapters;

package/dist/types-direct/runtime/rsc/createRscProxy.d.ts

@@ -0,0 +1,7 @@
+import { type RscSlotUsageEvent, type ServerComponentStream } from './symbols';
+export declare function createRscProxy(getTree: () => unknown, options?: {
+    renderable?: boolean;
+    slotUsages?: RscSlotUsageEvent[];
+    slotUsagesStream?: ReadableStream<RscSlotUsageEvent>;
+    stream?: ServerComponentStream;
+}): any;

package/dist/types-direct/runtime/rsc/index.d.ts

@@ -0,0 +1,2 @@
+export { CompositeComponent, getTanstackRscSerializationAdapters, rscSerializationAdapter, } from './client';
+export type { AnyCompositeComponent, AnyRenderableServerComponent, CompositeComponentProps, } from './symbols';

package/dist/types-direct/runtime/rsc/payloadRouter.d.ts

@@ -0,0 +1,24 @@
+import type { ServerPayload } from '@modern-js/runtime/context';
+type PayloadDecoder = (stream: ReadableStream<Uint8Array>) => Promise<unknown>;
+type TanstackPayloadRouterLike = {
+    state?: {
+        location?: unknown;
+        matches?: unknown;
+        statusCode?: unknown;
+    };
+};
+type LoadRouteDataOptions = {
+    hasClientLoader?: boolean;
+    loadClientData: () => Promise<unknown>;
+    request: Request;
+    routeId?: string;
+};
+export declare function createTanstackRscServerPayload(router: TanstackPayloadRouterLike, options?: {
+    omitClientLoaderData?: boolean;
+}): ServerPayload;
+export declare function handleTanstackRscRedirect(headers: Headers, basename: string, status: number): Response;
+export declare function isTanstackRscPayloadNavigationEnabled(): boolean;
+export declare function loadTanstackRscPayload(request: Request): Promise<ServerPayload>;
+export declare function loadTanstackRscRouteData({ hasClientLoader, loadClientData, request, routeId, }: LoadRouteDataOptions): Promise<unknown>;
+export declare function __setTanstackRscPayloadDecoderForTests(decoder?: PayloadDecoder): void;
+export {};

package/dist/types-direct/runtime/rsc/server.d.ts

@@ -0,0 +1,14 @@
+import { RawStream } from '@tanstack/router-core';
+import React from 'react';
+import { type AnyCompositeComponent, type AnyRenderableServerComponent, type RscSlotUsageEvent } from './symbols';
+export { CompositeComponent } from './CompositeComponent';
+export type { AnyCompositeComponent, AnyRenderableServerComponent, CompositeComponentProps, } from './symbols';
+export declare function renderServerComponent<TNode extends React.ReactNode>(node: TNode): Promise<TNode & AnyRenderableServerComponent<TNode>>;
+export declare function createCompositeComponent<TProps extends object = Record<string, unknown>, TReturn = React.ReactNode>(component: (props: TProps) => React.ReactNode | Promise<React.ReactNode>): Promise<AnyCompositeComponent<TProps, TReturn>>;
+type SerializedRsc = {
+    kind: 'renderable' | 'composite';
+    stream: RawStream;
+    slotUsagesStream?: ReadableStream<RscSlotUsageEvent>;
+};
+export declare function getTanstackRscSerializationAdapters(): import("@tanstack/router-core").SerializationAdapter<AnyCompositeComponent<Record<string, unknown>, React.ReactNode> | AnyRenderableServerComponent<React.ReactNode>, SerializedRsc, never>[];
+export declare const rscSerializationAdapter: typeof getTanstackRscSerializationAdapters;

package/dist/types-direct/runtime/rsc/slotUsageSanitizer.d.ts

@@ -0,0 +1,2 @@
+import type { SerializableSlotArg } from './symbols';
+export declare function sanitizeSlotArgs(args: unknown[]): SerializableSlotArg[];

package/dist/types-direct/runtime/rsc/symbols.d.ts

@@ -0,0 +1,46 @@
+import type React from 'react';
+export interface ServerComponentStream {
+    createReplayStream: () => ReadableStream<Uint8Array>;
+}
+export declare const SERVER_COMPONENT_STREAM: unique symbol;
+export declare const RENDERABLE_RSC: unique symbol;
+export declare const RSC_PROXY_GET_TREE: unique symbol;
+export declare const RSC_PROXY_PATH: unique symbol;
+export declare const RSC_SLOT_USAGES_STREAM: unique symbol;
+export declare const RSC_SLOT_USAGES: unique symbol;
+export type SerializableSlotArg = string | number | boolean | bigint | null | undefined | SerializableSlotArg[] | {
+    [key: string]: SerializableSlotArg;
+};
+export type RscSlotUsageEvent = {
+    slot: string;
+    args?: SerializableSlotArg[];
+};
+export interface AnyRenderableServerComponent<TNode = React.ReactNode> {
+    [SERVER_COMPONENT_STREAM]: ServerComponentStream;
+    [RENDERABLE_RSC]: true;
+    [RSC_PROXY_GET_TREE]?: () => unknown;
+    [RSC_PROXY_PATH]?: string[];
+    [RSC_SLOT_USAGES_STREAM]?: ReadableStream<RscSlotUsageEvent>;
+    '~types'?: {
+        node: TNode;
+    };
+}
+export interface AnyCompositeComponent<TProps extends object = Record<string, unknown>, TReturn = React.ReactNode> {
+    [SERVER_COMPONENT_STREAM]?: ServerComponentStream;
+    [RSC_PROXY_GET_TREE]?: () => unknown;
+    [RSC_PROXY_PATH]?: string[];
+    [RSC_SLOT_USAGES]?: RscSlotUsageEvent[];
+    [RSC_SLOT_USAGES_STREAM]?: ReadableStream<RscSlotUsageEvent>;
+    '~types'?: {
+        props: TProps;
+        return: TReturn;
+    };
+}
+type InferCompositeProps<TComp extends AnyCompositeComponent> = TComp extends AnyCompositeComponent<infer TProps, unknown> ? TProps : Record<string, unknown>;
+export type CompositeComponentProps<TComp extends AnyCompositeComponent> = {
+    src: TComp;
+    strict?: boolean;
+} & InferCompositeProps<TComp>;
+export declare function isServerComponent(value: unknown): value is AnyCompositeComponent | AnyRenderableServerComponent;
+export declare function isRenderableServerComponent(value: unknown): boolean;
+export {};

package/dist/types-direct/runtime/types.d.ts

@@ -0,0 +1,68 @@
+import type { RequestContext } from '@modern-js/runtime-utils/node';
+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 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;
+    }>;
+    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 {};

package/dist/types-direct/runtime/utils.d.ts

@@ -0,0 +1,36 @@
+import type { RouteObject } from '@modern-js/runtime-utils/router';
+import type { NestedRoute, PageRoute, SSRMode } from '@modern-js/types';
+import React from 'react';
+type RouterConfig = {
+    routesConfig: {
+        globalApp?: React.ComponentType<any>;
+        routes?: (NestedRoute | PageRoute)[];
+    };
+};
+type GlobalAppProps = {
+    Component: React.ComponentType;
+    [key: string]: unknown;
+};
+export type ModernRouteObject = RouteObject & {
+    isClientComponent?: boolean;
+    hasClientLoader?: boolean;
+    hasLoader?: boolean;
+    hasAction?: boolean;
+    inValidSSRRoute?: boolean;
+    lazyImport?: () => Promise<{
+        default: React.ComponentType;
+    }>;
+};
+export declare function getRouteObjects(routes: (NestedRoute | PageRoute)[], { globalApp, ssrMode, props, }: {
+    globalApp?: React.ComponentType<GlobalAppProps>;
+    ssrMode?: SSRMode;
+    props?: Record<string, unknown>;
+}): RouteObject[];
+export declare function createRouteObjectsFromConfig({ routesConfig, props, ssrMode, }: {
+    routesConfig: RouterConfig['routesConfig'];
+    props?: Record<string, unknown>;
+    ssrMode?: SSRMode;
+}): RouteObject[] | null;
+export declare const urlJoin: (...parts: string[]) => string;
+export declare function standardSlash(str: string): string;
+export {};

package/dist/types-direct/runtime.d.ts

@@ -0,0 +1 @@
+export * from './runtime/index';

package/package.json

@@ -0,0 +1,126 @@
+{
+  "name": "@bleedingdev/modern-js-plugin-tanstack",
+  "description": "TanStack Router integration for Modern.js.",
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/runtime/plugin-tanstack"
+  },
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js",
+    "tanstack-router"
+  ],
+  "version": "3.2.0-ultramodern.0",
+  "engines": {
+    "node": ">=20"
+  },
+  "types": "./dist/types/cli/index.d.ts",
+  "main": "./dist/cjs/cli/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/cli/index.d.ts",
+      "node": {
+        "import": "./dist/esm-node/cli/index.mjs",
+        "require": "./dist/cjs/cli/index.js"
+      },
+      "default": "./dist/cjs/cli/index.js"
+    },
+    "./package.json": "./package.json",
+    "./cli": {
+      "types": "./dist/types/cli/index.d.ts",
+      "node": {
+        "import": "./dist/esm-node/cli/index.mjs",
+        "require": "./dist/cjs/cli/index.js"
+      },
+      "default": "./dist/cjs/cli/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/types/runtime/index.d.ts",
+      "node": {
+        "module": "./dist/esm/runtime/index.mjs"
+      },
+      "default": "./dist/esm/runtime/index.mjs"
+    },
+    "./runtime/rsc": {
+      "types": "./dist/types/runtime/rsc/index.d.ts",
+      "default": "./dist/esm/runtime/rsc/index.mjs"
+    },
+    "./runtime/rsc/client": {
+      "types": "./dist/types/runtime/rsc/client.d.ts",
+      "default": "./dist/esm/runtime/rsc/client.mjs"
+    },
+    "./runtime/rsc/server": {
+      "types": "./dist/types/runtime/rsc/server.d.ts",
+      "default": "./dist/esm/runtime/rsc/server.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types/cli/index.d.ts"
+      ],
+      "cli": [
+        "./dist/types/cli/index.d.ts"
+      ],
+      "runtime": [
+        "./dist/types/runtime/index.d.ts"
+      ],
+      "runtime/rsc": [
+        "./dist/types/runtime/rsc/index.d.ts"
+      ],
+      "runtime/rsc/client": [
+        "./dist/types/runtime/rsc/client.d.ts"
+      ],
+      "runtime/rsc/server": [
+        "./dist/types/runtime/rsc/server.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@swc/helpers": "^0.5.21",
+    "@tanstack/react-router": "1.170.1",
+    "@tanstack/router-core": "1.170.1",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.2.0-ultramodern.0",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.0",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.0",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.0"
+  },
+  "peerDependencies": {
+    "@modern-js/runtime": "3.2.0-ultramodern.0",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6"
+  },
+  "devDependencies": {
+    "@rslib/core": "0.21.5",
+    "@tanstack/history": "1.162.0",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^25.8.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@typescript/native-preview": "7.0.0-dev.20260516.1",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.2.0-ultramodern.0",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.2.0-ultramodern.0",
+    "@scripts/rstest-config": "2.66.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "rslib build --watch",
+    "build": "rslib build && pnpm -w tsgo:dts \"$PWD\"",
+    "test": "rstest --passWithNoTests"
+  }
+}

package/rslib.config.mts

@@ -0,0 +1,4 @@
+import { rslibConfig } from '@modern-js/rslib';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig(rslibConfig);

package/rstest.config.mts

@@ -0,0 +1,43 @@
+import type { ProjectConfig } from '@rstest/core';
+import { withTestPreset } from '@scripts/rstest-config';
+
+const commonConfig: ProjectConfig = {
+  setupFiles: ['@scripts/rstest-config/setup.ts'],
+  globals: true,
+  tools: {
+    swc: {
+      jsc: {
+        transform: {
+          react: {
+            runtime: 'automatic',
+          },
+        },
+      },
+    },
+  },
+};
+
+export default {
+  projects: [
+    withTestPreset({
+      name: 'plugin-tanstack-node',
+      testEnvironment: 'node',
+      include: [
+        'tests/router/cli.test.ts',
+        'tests/router/rsc.test.tsx',
+        'tests/router/tanstackTypes.test.ts',
+        'tests/router/routeTree.test.ts',
+      ],
+      extends: commonConfig,
+    }),
+    withTestPreset({
+      name: 'plugin-tanstack-client',
+      testEnvironment: 'happy-dom',
+      include: [
+        'tests/router/dataMutation.test.tsx',
+        'tests/router/prefetchLink.test.tsx',
+      ],
+      extends: commonConfig,
+    }),
+  ],
+};