diff --git a/examples/mock/mock/app.ts b/examples/mock/mock/app.ts
new file mode 100644
index 0000000..3d3bb45
--- /dev/null
+++ b/examples/mock/mock/app.ts
@@ -0,0 +1,99 @@
+import { Request, Response } from 'express';
+import { umimock2msw } from './umimock2msw';
+
+export default umimock2msw({
+ 'POST /api/hello': {
+ text: 'Alita',
+ },
+ 'POST /api/list': (req: Request, res: Response) => {
+ const dataSource = [
+ {
+ id: 1,
+ title: 'Ant Design Title 1',
+ },
+ {
+ id: 2,
+ title: 'Ant Design Title 2',
+ },
+ {
+ id: 3,
+ title: 'Ant Design Title 3',
+ },
+ {
+ id: 4,
+ title: 'Ant Design Title 4',
+ },
+ {
+ id: 5,
+ title: 'Ant Design Title 5',
+ },
+ {
+ id: 6,
+ title: 'Ant Design Title 6',
+ },
+ {
+ id: 7,
+ title: 'Ant Design Title 7',
+ },
+ {
+ id: 8,
+ title: 'Ant Design Title 8',
+ },
+ {
+ id: 9,
+ title: 'Ant Design Title 9',
+ },
+ {
+ id: 10,
+ title: 'Ant Design Title 10',
+ },
+ {
+ id: 11,
+ title: 'Ant Design Title 11',
+ },
+ {
+ id: 12,
+ title: 'Ant Design Title 12',
+ },
+ {
+ id: 13,
+ title: 'Ant Design Title 13',
+ },
+ {
+ id: 14,
+ title: 'Ant Design Title 14',
+ },
+ {
+ id: 15,
+ title: 'Ant Design Title 15',
+ },
+ {
+ id: 16,
+ title: 'Ant Design Title 16',
+ },
+ {
+ id: 17,
+ title: 'Ant Design Title 17',
+ },
+ {
+ id: 18,
+ title: 'Ant Design Title 18',
+ },
+ {
+ id: 19,
+ title: 'Ant Design Title 19',
+ },
+ {
+ id: 20,
+ title: 'Ant Design Title 20',
+ },
+ ];
+ const { body } = req;
+
+ const { pageSize, offset } = body;
+ return res.json({
+ total: dataSource.length,
+ data: dataSource.slice(offset, offset + pageSize),
+ });
+ },
+});
diff --git a/examples/mock/mock/browser.ts b/examples/mock/mock/browser.ts
new file mode 100644
index 0000000..3dd7dfa
--- /dev/null
+++ b/examples/mock/mock/browser.ts
@@ -0,0 +1,5 @@
+import { setupWorker } from 'msw/browser';
+import app from './app';
+import { handlers } from './handlers';
+
+export const worker = setupWorker(...handlers, ...app);
diff --git a/examples/mock/mock/handlers.ts b/examples/mock/mock/handlers.ts
new file mode 100644
index 0000000..bd81fbf
--- /dev/null
+++ b/examples/mock/mock/handlers.ts
@@ -0,0 +1,27 @@
+import { HttpResponse, graphql, http } from 'msw';
+
+export const handlers = [
+ http.get('/user', () => {
+ return HttpResponse.json({
+ firstName: 'John',
+ lastName: 'Maverick',
+ });
+ }),
+ graphql.query('ListMovies', () => {
+ return HttpResponse.json({
+ data: {
+ movies: [
+ {
+ title: 'The Lord of The Rings',
+ },
+ {
+ title: 'The Matrix',
+ },
+ {
+ title: 'Star Wars: The Empire Strikes Back',
+ },
+ ],
+ },
+ });
+ }),
+];
diff --git a/examples/mock/mock/node.ts b/examples/mock/mock/node.ts
new file mode 100644
index 0000000..e52fee0
--- /dev/null
+++ b/examples/mock/mock/node.ts
@@ -0,0 +1,4 @@
+import { setupServer } from 'msw/node';
+import { handlers } from './handlers';
+
+export const server = setupServer(...handlers);
diff --git a/examples/mock/mock/umimock2msw.ts b/examples/mock/mock/umimock2msw.ts
new file mode 100644
index 0000000..e2274ee
--- /dev/null
+++ b/examples/mock/mock/umimock2msw.ts
@@ -0,0 +1,74 @@
+import assert from 'assert';
+import { HttpResponse, http } from 'msw';
+
+export const VALID_METHODS = [
+ 'GET',
+ 'POST',
+ 'PUT',
+ 'DELETE',
+ 'PATCH',
+ 'HEAD',
+ 'OPTIONS',
+];
+export const DEFAULT_METHOD = 'GET';
+export const MOCK_FILE_GLOB = '**/*.[jt]s';
+
+export interface IMock {
+ method: string;
+ path: string;
+ handler: Function;
+ file?: string;
+}
+
+function getMock(opts: { key: string; obj: any }): IMock {
+ const { method, path } = parseKey(opts.key);
+ const handler = opts.obj[opts.key];
+ return { method, path, handler };
+}
+
+function parseKey(key: string) {
+ const spliced = key.split(/\s+/);
+ const len = spliced.length;
+ if (len === 1) {
+ return { method: DEFAULT_METHOD, path: key };
+ } else {
+ const [method = 'GET', path] = spliced;
+ const upperCaseMethod = method.toUpperCase();
+ assert(
+ VALID_METHODS.includes(upperCaseMethod),
+ `method ${method} is not supported`,
+ );
+ assert(path, `${key}, path is undefined`);
+
+ return { method: upperCaseMethod, path };
+ }
+}
+
+export const umimock2msw = (umiMock: any) => {
+ const handlers = [];
+ for (const key of Object.keys(umiMock)) {
+ const mock = getMock({ key, obj: umiMock });
+ if (typeof mock.handler === 'function') {
+ // handler
+ const upperCaseMethod = mock.method.toLowerCase();
+ handlers.push(
+ // @ts-ignore
+ http[upperCaseMethod](mock.path, async ({ request }) => {
+ const data = await request.json();
+ // FIXME: 这里只是做了兼容
+ const req = {
+ body: data,
+ };
+ return mock.handler(req, HttpResponse);
+ }),
+ );
+ } else {
+ handlers.push(
+ http.get(mock.path, () => {
+ return HttpResponse.json(mock.handler);
+ }),
+ );
+ }
+ }
+ return handlers;
+};
diff --git a/examples/mock/package.json b/examples/mock/package.json
new file mode 100644
index 0000000..5881a15
--- /dev/null
+++ b/examples/mock/package.json
@@ -0,0 +1,19 @@
+{
+ "name": "@examples/mock",
+ "private": true,
+ "scripts": {
+ "build": "tnf build",
+ "dev": "tnf dev"
+ },
+ "dependencies": {
+ "@types/react": "^18.3.12",
+ "@types/react-dom": "^18.3.1",
+ "@umijs/tnf": "workspace:*",
+ "msw": "^2.6.0"
+ },
+ "msw": {
+ "workerDirectory": [
+ "public"
+ ]
+ }
+}
diff --git a/examples/mock/public/index.html b/examples/mock/public/index.html
new file mode 100644
index 0000000..a7dedd0
--- /dev/null
+++ b/examples/mock/public/index.html
@@ -0,0 +1,13 @@
+
+
+
+
+
+ Document
+
+
+
+
+
+
+
diff --git a/examples/mock/public/mockServiceWorker.js b/examples/mock/public/mockServiceWorker.js
new file mode 100644
index 0000000..6eb8052
--- /dev/null
+++ b/examples/mock/public/mockServiceWorker.js
@@ -0,0 +1,293 @@
+/* eslint-disable */
+/* tslint:disable */
+
+/**
+ * Mock Service Worker.
+ * @see https://github.com/mswjs/msw
+ * - Please do NOT modify this file.
+ * - Please do NOT serve this file on production.
+ */
+
+const PACKAGE_VERSION = '2.6.0'
+const INTEGRITY_CHECKSUM = '07a8241b182f8a246a7cd39894799a9e'
+const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
+const activeClientIds = new Set()
+
+self.addEventListener('install', function () {
+ self.skipWaiting()
+})
+
+self.addEventListener('activate', function (event) {
+ event.waitUntil(self.clients.claim())
+})
+
+self.addEventListener('message', async function (event) {
+ const clientId = event.source.id
+
+ if (!clientId || !self.clients) {
+ return
+ }
+
+ const client = await self.clients.get(clientId)
+
+ if (!client) {
+ return
+ }
+
+ const allClients = await self.clients.matchAll({
+ type: 'window',
+ })
+
+ switch (event.data) {
+ case 'KEEPALIVE_REQUEST': {
+ sendToClient(client, {
+ type: 'KEEPALIVE_RESPONSE',
+ })
+ break
+ }
+
+ case 'INTEGRITY_CHECK_REQUEST': {
+ sendToClient(client, {
+ type: 'INTEGRITY_CHECK_RESPONSE',
+ payload: {
+ packageVersion: PACKAGE_VERSION,
+ checksum: INTEGRITY_CHECKSUM,
+ },
+ })
+ break
+ }
+
+ case 'MOCK_ACTIVATE': {
+ activeClientIds.add(clientId)
+
+ sendToClient(client, {
+ type: 'MOCKING_ENABLED',
+ payload: {
+ client: {
+ id: client.id,
+ frameType: client.frameType,
+ },
+ },
+ })
+ break
+ }
+
+ case 'MOCK_DEACTIVATE': {
+ activeClientIds.delete(clientId)
+ break
+ }
+
+ case 'CLIENT_CLOSED': {
+ activeClientIds.delete(clientId)
+
+ const remainingClients = allClients.filter((client) => {
+ return client.id !== clientId
+ })
+
+ // Unregister itself when there are no more clients
+ if (remainingClients.length === 0) {
+ self.registration.unregister()
+ }
+
+ break
+ }
+ }
+})
+
+self.addEventListener('fetch', function (event) {
+ const { request } = event
+
+ // Bypass navigation requests.
+ if (request.mode === 'navigate') {
+ return
+ }
+
+ // Opening the DevTools triggers the "only-if-cached" request
+ // that cannot be handled by the worker. Bypass such requests.
+ if (request.cache === 'only-if-cached' && request.mode !== 'same-origin') {
+ return
+ }
+
+ // Bypass all requests when there are no active clients.
+ // Prevents the self-unregistered worked from handling requests
+ // after it's been deleted (still remains active until the next reload).
+ if (activeClientIds.size === 0) {
+ return
+ }
+
+ // Generate unique request ID.
+ const requestId = crypto.randomUUID()
+ event.respondWith(handleRequest(event, requestId))
+})
+
+async function handleRequest(event, requestId) {
+ const client = await resolveMainClient(event)
+ const response = await getResponse(event, client, requestId)
+
+ // Send back the response clone for the "response:*" life-cycle events.
+ // Ensure MSW is active and ready to handle the message, otherwise
+ // this message will pend indefinitely.
+ if (client && activeClientIds.has(client.id)) {
+ ;(async function () {
+ const responseClone = response.clone()
+
+ sendToClient(
+ client,
+ {
+ type: 'RESPONSE',
+ payload: {
+ requestId,
+ isMockedResponse: IS_MOCKED_RESPONSE in response,
+ type: responseClone.type,
+ status: responseClone.status,
+ statusText: responseClone.statusText,
+ body: responseClone.body,
+ headers: Object.fromEntries(responseClone.headers.entries()),
+ },
+ },
+ [responseClone.body],
+ )
+ })()
+ }
+
+ return response
+}
+
+// Resolve the main client for the given event.
+// Client that issues a request doesn't necessarily equal the client
+// that registered the worker. It's with the latter the worker should
+// communicate with during the response resolving phase.
+async function resolveMainClient(event) {
+ const client = await self.clients.get(event.clientId)
+
+ if (activeClientIds.has(event.clientId)) {
+ return client
+ }
+
+ if (client?.frameType === 'top-level') {
+ return client
+ }
+
+ const allClients = await self.clients.matchAll({
+ type: 'window',
+ })
+
+ return allClients
+ .filter((client) => {
+ // Get only those clients that are currently visible.
+ return client.visibilityState === 'visible'
+ })
+ .find((client) => {
+ // Find the client ID that's recorded in the
+ // set of clients that have registered the worker.
+ return activeClientIds.has(client.id)
+ })
+}
+
+async function getResponse(event, client, requestId) {
+ const { request } = event
+
+ // Clone the request because it might've been already used
+ // (i.e. its body has been read and sent to the client).
+ const requestClone = request.clone()
+
+ function passthrough() {
+ const headers = Object.fromEntries(requestClone.headers.entries())
+
+ // Remove internal MSW request header so the passthrough request
+ // complies with any potential CORS preflight checks on the server.
+ // Some servers forbid unknown request headers.
+ delete headers['x-msw-intention']
+
+ return fetch(requestClone, { headers })
+ }
+
+ // Bypass mocking when the client is not active.
+ if (!client) {
+ return passthrough()
+ }
+
+ // Bypass initial page load requests (i.e. static assets).
+ // The absence of the immediate/parent client in the map of the active clients
+ // means that MSW hasn't dispatched the "MOCK_ACTIVATE" event yet
+ // and is not ready to handle requests.
+ if (!activeClientIds.has(client.id)) {
+ return passthrough()
+ }
+
+ // Notify the client that a request has been intercepted.
+ const requestBuffer = await request.arrayBuffer()
+ const clientMessage = await sendToClient(
+ client,
+ {
+ type: 'REQUEST',
+ payload: {
+ id: requestId,
+ url: request.url,
+ mode: request.mode,
+ method: request.method,
+ headers: Object.fromEntries(request.headers.entries()),
+ cache: request.cache,
+ credentials: request.credentials,
+ destination: request.destination,
+ integrity: request.integrity,
+ redirect: request.redirect,
+ referrer: request.referrer,
+ referrerPolicy: request.referrerPolicy,
+ body: requestBuffer,
+ keepalive: request.keepalive,
+ },
+ },
+ [requestBuffer],
+ )
+
+ switch (clientMessage.type) {
+ case 'MOCK_RESPONSE': {
+ return respondWithMock(clientMessage.data)
+ }
+
+ case 'PASSTHROUGH': {
+ return passthrough()
+ }
+ }
+
+ return passthrough()
+}
+
+function sendToClient(client, message, transferrables = []) {
+ return new Promise((resolve, reject) => {
+ const channel = new MessageChannel()
+
+ channel.port1.onmessage = (event) => {
+ if (event.data && event.data.error) {
+ return reject(event.data.error)
+ }
+
+ resolve(event.data)
+ }
+
+ client.postMessage(
+ message,
+ [channel.port2].concat(transferrables.filter(Boolean)),
+ )
+ })
+}
+
+async function respondWithMock(response) {
+ // Setting response status code to 0 is a no-op.
+ // However, when responding with a "Response.error()", the produced Response
+ // instance will have status code set to 0. Since it's not possible to create
+ // a Response instance with status code 0, handle that use-case separately.
+ if (response.status === 0) {
+ return Response.error()
+ }
+
+ const mockedResponse = new Response(response.body, response)
+
+ Reflect.defineProperty(mockedResponse, IS_MOCKED_RESPONSE, {
+ value: true,
+ enumerable: true,
+ })
+
+ return mockedResponse
+}
diff --git a/examples/mock/src/pages/__root.tsx b/examples/mock/src/pages/__root.tsx
new file mode 100644
index 0000000..44b3394
--- /dev/null
+++ b/examples/mock/src/pages/__root.tsx
@@ -0,0 +1,11 @@
+import React from 'react';
+import { Outlet, createRootRoute } from '@umijs/tnf/router';
+
+export const Route = createRootRoute({
+ component: () => (
+ <>
+ Hello "__root"!
+
+
+ ),
+});
diff --git a/examples/mock/src/pages/index.module.less b/examples/mock/src/pages/index.module.less
new file mode 100644
index 0000000..213d067
--- /dev/null
+++ b/examples/mock/src/pages/index.module.less
@@ -0,0 +1,3 @@
+.foo {
+ color: green;
+}
diff --git a/examples/mock/src/pages/index.tsx b/examples/mock/src/pages/index.tsx
new file mode 100644
index 0000000..d86c309
--- /dev/null
+++ b/examples/mock/src/pages/index.tsx
@@ -0,0 +1,32 @@
+import React, { useEffect, useState } from 'react';
+import { createFileRoute } from '@umijs/tnf/router';
+import styles from './index.module.less';
+
+export const Route = createFileRoute('/')({
+ component: Home,
+});
+
+function Home() {
+ const [list, setList] = useState([]);
+ useEffect(() => {
+ fetch('/api/list', {
+ method: 'post',
+ body: JSON.stringify({
+ pageSize: 10,
+ offset: 0,
+ }),
+ })
+ .then((response) => response.json())
+ .then((user) => setList(user.data));
+ }, []);
+ return (
+
+
Welcome Home!
+
+ {list.map((i: any) => (
+ - {i.title}
+ ))}
+
+