msw-fetch-mock 0.3.0 → 0.3.2

package/dist/fetch-mock-DhiqmHdF.d.cts

@@ -0,0 +1,199 @@
+interface MockCallHistoryLogData {
+    body: string | null;
+    method: string;
+    headers: Record<string, string>;
+    fullUrl: string;
+    origin: string;
+    path: string;
+    searchParams: Record<string, string>;
+    protocol: string;
+    host: string;
+    port: string;
+    hash: string;
+}
+declare class MockCallHistoryLog {
+    readonly body: string | null;
+    readonly method: string;
+    readonly headers: Record<string, string>;
+    readonly fullUrl: string;
+    readonly origin: string;
+    readonly path: string;
+    readonly searchParams: Record<string, string>;
+    readonly protocol: string;
+    readonly host: string;
+    readonly port: string;
+    readonly hash: string;
+    constructor(data: MockCallHistoryLogData);
+    json(): unknown;
+    toMap(): Map<string, string | null | Record<string, string>>;
+    toString(): string;
+}
+interface CallHistoryFilterCriteria {
+    method?: string;
+    path?: string;
+    origin?: string;
+    protocol?: string;
+    host?: string;
+    port?: string;
+    hash?: string;
+    fullUrl?: string;
+}
+declare class MockCallHistory {
+    private logs;
+    get length(): number;
+    record(data: MockCallHistoryLogData): void;
+    called(criteria?: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp): boolean;
+    calls(): MockCallHistoryLog[];
+    firstCall(criteria?: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp): MockCallHistoryLog | undefined;
+    lastCall(criteria?: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp): MockCallHistoryLog | undefined;
+    nthCall(n: number, criteria?: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp): MockCallHistoryLog | undefined;
+    clear(): void;
+    [Symbol.iterator](): Iterator<MockCallHistoryLog>;
+    filterCalls(criteria: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp, options?: {
+        operator?: 'AND' | 'OR';
+    }): MockCallHistoryLog[];
+    private filterBy;
+    filterCallsByMethod(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByPath(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByOrigin(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByProtocol(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByHost(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByPort(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByHash(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByFullUrl(filter: string | RegExp): MockCallHistoryLog[];
+}
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type PathMatcher = string | RegExp | ((path: string) => boolean);
+type HeaderValueMatcher = string | RegExp | ((value: string) => boolean);
+type BodyMatcher = string | RegExp | ((body: string) => boolean);
+interface InterceptOptions {
+    path: PathMatcher;
+    method?: HttpMethod;
+    headers?: Record<string, HeaderValueMatcher>;
+    body?: BodyMatcher;
+    query?: Record<string, string>;
+}
+interface ReplyOptions {
+    headers?: Record<string, string>;
+}
+type ReplyCallback = (req: {
+    body: string | null;
+}) => unknown | Promise<unknown>;
+interface SingleReplyResult {
+    statusCode: number;
+    data: unknown;
+    responseOptions?: ReplyOptions;
+}
+type SingleReplyCallback = (req: {
+    body: string | null;
+}) => SingleReplyResult | Promise<SingleReplyResult>;
+interface MockReplyChain {
+    times(n: number): void;
+    persist(): void;
+    delay(ms: number): void;
+    replyContentLength(): void;
+}
+interface MockInterceptor {
+    reply(status: number, body?: unknown, options?: ReplyOptions): MockReplyChain;
+    reply(status: number, callback: ReplyCallback): MockReplyChain;
+    reply(callback: SingleReplyCallback): MockReplyChain;
+    replyWithError(error?: Error): MockReplyChain;
+}
+interface MockPool {
+    intercept(options: InterceptOptions): MockInterceptor;
+}
+interface PendingInterceptor {
+    origin: string;
+    path: string;
+    method: string;
+    consumed: boolean;
+    times: number;
+    timesInvoked: number;
+    persist: boolean;
+}
+type PrintAPI = {
+    warning(): void;
+    error(): void;
+};
+type OnUnhandledRequestCallback = (request: Request, print: PrintAPI) => void;
+type OnUnhandledRequest = 'bypass' | 'warn' | 'error' | OnUnhandledRequestCallback;
+interface ActivateOptions {
+    onUnhandledRequest?: OnUnhandledRequest;
+}
+interface ResolvedActivateOptions {
+    onUnhandledRequest: OnUnhandledRequestCallback;
+}
+/** Structural type to avoid cross-package nominal type mismatch on MSW's private fields */
+interface SetupServerLike {
+    use(...handlers: Array<unknown>): void;
+    resetHandlers(...handlers: Array<unknown>): void;
+    listen(options?: Record<string, unknown>): void;
+    close(): void;
+}
+/** Structural type for MSW's setupWorker return type */
+interface SetupWorkerLike {
+    use(...handlers: Array<unknown>): void;
+    resetHandlers(...handlers: Array<unknown>): void;
+    start(options?: Record<string, unknown>): Promise<void>;
+    stop(): void;
+}
+/** Environment-agnostic adapter interface for MSW server/worker */
+interface MswAdapter {
+    use(...handlers: Array<unknown>): void;
+    resetHandlers(...handlers: Array<unknown>): void;
+    activate(options: ResolvedActivateOptions): void | Promise<void>;
+    deactivate(): void;
+}
+/** Pluggable factory for MSW-version-specific handler and response creation */
+interface HandlerFactory {
+    createHandler(method: HttpMethod, urlPattern: string | RegExp, handlerFn: (request: Request) => Promise<Response | undefined>): unknown;
+    buildResponse(status: number, body: unknown, headers?: Headers): Response;
+    buildErrorResponse(): Response;
+}
+
+declare class FetchMock {
+    /** @internal */
+    static _defaultAdapterFactory?: () => MswAdapter;
+    /** @internal */
+    static _handlerFactory?: HandlerFactory;
+    private get handlerFactory();
+    private buildResponse;
+    private readonly _calls;
+    private adapter;
+    private interceptors;
+    private netConnectAllowed;
+    private mswHandlers;
+    private _defaultReplyHeaders;
+    private _callHistoryEnabled;
+    get calls(): MockCallHistory;
+    constructor(input?: SetupServerLike | SetupWorkerLike | MswAdapter);
+    activate(options?: ActivateOptions): Promise<void>;
+    disableNetConnect(): void;
+    enableNetConnect(matcher?: string | RegExp | ((host: string) => boolean)): void;
+    private isNetConnectAllowed;
+    /**
+     * Remove consumed MSW handlers so future requests to those URLs
+     * go through MSW's onUnhandledRequest instead of silently passing through.
+     */
+    private syncMswHandlers;
+    getCallHistory(): MockCallHistory;
+    clearCallHistory(): void;
+    clearAllCallHistory(): void;
+    defaultReplyHeaders(headers: Record<string, string>): void;
+    enableCallHistory(): void;
+    disableCallHistory(): void;
+    deactivate(): void;
+    reset(): void;
+    assertNoPendingInterceptors(): void;
+    pendingInterceptors(): PendingInterceptor[];
+    private resolveUrlPattern;
+    private matchOriginAndPath;
+    private matchAndConsume;
+    private registerHandler;
+    private createMatchingHandler;
+    private buildChain;
+    get(origin: string | RegExp | ((origin: string) => boolean)): MockPool;
+}
+
+export { type ActivateOptions as A, type CallHistoryFilterCriteria as C, FetchMock as F, type HandlerFactory as H, type InterceptOptions as I, type MswAdapter as M, type OnUnhandledRequest as O, type PendingInterceptor as P, type ResolvedActivateOptions as R, type SetupWorkerLike as S, MockCallHistory as a, MockCallHistoryLog as b, type MockCallHistoryLogData as c, type MockInterceptor as d, type MockPool as e, type MockReplyChain as f, type ReplyOptions as g, type HttpMethod as h, type SetupServerLike as i, type ReplyCallback as j, type SingleReplyCallback as k, type SingleReplyResult as l };

package/dist/fetch-mock-DhiqmHdF.d.ts

@@ -0,0 +1,199 @@
+interface MockCallHistoryLogData {
+    body: string | null;
+    method: string;
+    headers: Record<string, string>;
+    fullUrl: string;
+    origin: string;
+    path: string;
+    searchParams: Record<string, string>;
+    protocol: string;
+    host: string;
+    port: string;
+    hash: string;
+}
+declare class MockCallHistoryLog {
+    readonly body: string | null;
+    readonly method: string;
+    readonly headers: Record<string, string>;
+    readonly fullUrl: string;
+    readonly origin: string;
+    readonly path: string;
+    readonly searchParams: Record<string, string>;
+    readonly protocol: string;
+    readonly host: string;
+    readonly port: string;
+    readonly hash: string;
+    constructor(data: MockCallHistoryLogData);
+    json(): unknown;
+    toMap(): Map<string, string | null | Record<string, string>>;
+    toString(): string;
+}
+interface CallHistoryFilterCriteria {
+    method?: string;
+    path?: string;
+    origin?: string;
+    protocol?: string;
+    host?: string;
+    port?: string;
+    hash?: string;
+    fullUrl?: string;
+}
+declare class MockCallHistory {
+    private logs;
+    get length(): number;
+    record(data: MockCallHistoryLogData): void;
+    called(criteria?: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp): boolean;
+    calls(): MockCallHistoryLog[];
+    firstCall(criteria?: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp): MockCallHistoryLog | undefined;
+    lastCall(criteria?: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp): MockCallHistoryLog | undefined;
+    nthCall(n: number, criteria?: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp): MockCallHistoryLog | undefined;
+    clear(): void;
+    [Symbol.iterator](): Iterator<MockCallHistoryLog>;
+    filterCalls(criteria: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp, options?: {
+        operator?: 'AND' | 'OR';
+    }): MockCallHistoryLog[];
+    private filterBy;
+    filterCallsByMethod(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByPath(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByOrigin(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByProtocol(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByHost(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByPort(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByHash(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByFullUrl(filter: string | RegExp): MockCallHistoryLog[];
+}
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type PathMatcher = string | RegExp | ((path: string) => boolean);
+type HeaderValueMatcher = string | RegExp | ((value: string) => boolean);
+type BodyMatcher = string | RegExp | ((body: string) => boolean);
+interface InterceptOptions {
+    path: PathMatcher;
+    method?: HttpMethod;
+    headers?: Record<string, HeaderValueMatcher>;
+    body?: BodyMatcher;
+    query?: Record<string, string>;
+}
+interface ReplyOptions {
+    headers?: Record<string, string>;
+}
+type ReplyCallback = (req: {
+    body: string | null;
+}) => unknown | Promise<unknown>;
+interface SingleReplyResult {
+    statusCode: number;
+    data: unknown;
+    responseOptions?: ReplyOptions;
+}
+type SingleReplyCallback = (req: {
+    body: string | null;
+}) => SingleReplyResult | Promise<SingleReplyResult>;
+interface MockReplyChain {
+    times(n: number): void;
+    persist(): void;
+    delay(ms: number): void;
+    replyContentLength(): void;
+}
+interface MockInterceptor {
+    reply(status: number, body?: unknown, options?: ReplyOptions): MockReplyChain;
+    reply(status: number, callback: ReplyCallback): MockReplyChain;
+    reply(callback: SingleReplyCallback): MockReplyChain;
+    replyWithError(error?: Error): MockReplyChain;
+}
+interface MockPool {
+    intercept(options: InterceptOptions): MockInterceptor;
+}
+interface PendingInterceptor {
+    origin: string;
+    path: string;
+    method: string;
+    consumed: boolean;
+    times: number;
+    timesInvoked: number;
+    persist: boolean;
+}
+type PrintAPI = {
+    warning(): void;
+    error(): void;
+};
+type OnUnhandledRequestCallback = (request: Request, print: PrintAPI) => void;
+type OnUnhandledRequest = 'bypass' | 'warn' | 'error' | OnUnhandledRequestCallback;
+interface ActivateOptions {
+    onUnhandledRequest?: OnUnhandledRequest;
+}
+interface ResolvedActivateOptions {
+    onUnhandledRequest: OnUnhandledRequestCallback;
+}
+/** Structural type to avoid cross-package nominal type mismatch on MSW's private fields */
+interface SetupServerLike {
+    use(...handlers: Array<unknown>): void;
+    resetHandlers(...handlers: Array<unknown>): void;
+    listen(options?: Record<string, unknown>): void;
+    close(): void;
+}
+/** Structural type for MSW's setupWorker return type */
+interface SetupWorkerLike {
+    use(...handlers: Array<unknown>): void;
+    resetHandlers(...handlers: Array<unknown>): void;
+    start(options?: Record<string, unknown>): Promise<void>;
+    stop(): void;
+}
+/** Environment-agnostic adapter interface for MSW server/worker */
+interface MswAdapter {
+    use(...handlers: Array<unknown>): void;
+    resetHandlers(...handlers: Array<unknown>): void;
+    activate(options: ResolvedActivateOptions): void | Promise<void>;
+    deactivate(): void;
+}
+/** Pluggable factory for MSW-version-specific handler and response creation */
+interface HandlerFactory {
+    createHandler(method: HttpMethod, urlPattern: string | RegExp, handlerFn: (request: Request) => Promise<Response | undefined>): unknown;
+    buildResponse(status: number, body: unknown, headers?: Headers): Response;
+    buildErrorResponse(): Response;
+}
+
+declare class FetchMock {
+    /** @internal */
+    static _defaultAdapterFactory?: () => MswAdapter;
+    /** @internal */
+    static _handlerFactory?: HandlerFactory;
+    private get handlerFactory();
+    private buildResponse;
+    private readonly _calls;
+    private adapter;
+    private interceptors;
+    private netConnectAllowed;
+    private mswHandlers;
+    private _defaultReplyHeaders;
+    private _callHistoryEnabled;
+    get calls(): MockCallHistory;
+    constructor(input?: SetupServerLike | SetupWorkerLike | MswAdapter);
+    activate(options?: ActivateOptions): Promise<void>;
+    disableNetConnect(): void;
+    enableNetConnect(matcher?: string | RegExp | ((host: string) => boolean)): void;
+    private isNetConnectAllowed;
+    /**
+     * Remove consumed MSW handlers so future requests to those URLs
+     * go through MSW's onUnhandledRequest instead of silently passing through.
+     */
+    private syncMswHandlers;
+    getCallHistory(): MockCallHistory;
+    clearCallHistory(): void;
+    clearAllCallHistory(): void;
+    defaultReplyHeaders(headers: Record<string, string>): void;
+    enableCallHistory(): void;
+    disableCallHistory(): void;
+    deactivate(): void;
+    reset(): void;
+    assertNoPendingInterceptors(): void;
+    pendingInterceptors(): PendingInterceptor[];
+    private resolveUrlPattern;
+    private matchOriginAndPath;
+    private matchAndConsume;
+    private registerHandler;
+    private createMatchingHandler;
+    private buildChain;
+    get(origin: string | RegExp | ((origin: string) => boolean)): MockPool;
+}
+
+export { type ActivateOptions as A, type CallHistoryFilterCriteria as C, FetchMock as F, type HandlerFactory as H, type InterceptOptions as I, type MswAdapter as M, type OnUnhandledRequest as O, type PendingInterceptor as P, type ResolvedActivateOptions as R, type SetupWorkerLike as S, MockCallHistory as a, MockCallHistoryLog as b, type MockCallHistoryLogData as c, type MockInterceptor as d, type MockPool as e, type MockReplyChain as f, type ReplyOptions as g, type HttpMethod as h, type SetupServerLike as i, type ReplyCallback as j, type SingleReplyCallback as k, type SingleReplyResult as l };

package/dist/index.cjs

@@ -0,0 +1,19 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkPJU5FUNIcjs = require('./chunk-PJU5FUNI.cjs');
+require('./chunk-QKIKWNFZ.cjs');
+
+
+
+
+var _chunkN6B7UP6Bcjs = require('./chunk-N6B7UP6B.cjs');
+
+
+
+
+
+
+
+exports.FetchMock = _chunkN6B7UP6Bcjs.FetchMock; exports.MockCallHistory = _chunkN6B7UP6Bcjs.MockCallHistory; exports.MockCallHistoryLog = _chunkN6B7UP6Bcjs.MockCallHistoryLog; exports.NodeMswAdapter = _chunkPJU5FUNIcjs.NodeMswAdapter; exports.createFetchMock = _chunkPJU5FUNIcjs.createFetchMock; exports.fetchMock = _chunkPJU5FUNIcjs.fetchMock;

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+export { NodeMswAdapter, createFetchMock, fetchMock } from './node.cjs';
+export { A as ActivateOptions, C as CallHistoryFilterCriteria, F as FetchMock, H as HandlerFactory, I as InterceptOptions, a as MockCallHistory, b as MockCallHistoryLog, c as MockCallHistoryLogData, d as MockInterceptor, e as MockPool, f as MockReplyChain, M as MswAdapter, O as OnUnhandledRequest, P as PendingInterceptor, j as ReplyCallback, g as ReplyOptions, i as SetupServerLike, k as SingleReplyCallback, l as SingleReplyResult } from './fetch-mock-DhiqmHdF.cjs';

package/dist/index.d.ts

@@ -1,3 +1,2 @@
-export { FetchMock, NodeMswAdapter, createFetchMock, fetchMock, MockCallHistory, MockCallHistoryLog, } from './node';
-export type { ActivateOptions, OnUnhandledRequest, InterceptOptions, MockPool, MockInterceptor, MockReplyChain, ReplyOptions, PendingInterceptor, MswAdapter, SetupServerLike, MockCallHistoryLogData, CallHistoryFilterCriteria, } from './node';
-//# sourceMappingURL=index.d.ts.map
+export { NodeMswAdapter, createFetchMock, fetchMock } from './node.js';
+export { A as ActivateOptions, C as CallHistoryFilterCriteria, F as FetchMock, H as HandlerFactory, I as InterceptOptions, a as MockCallHistory, b as MockCallHistoryLog, c as MockCallHistoryLogData, d as MockInterceptor, e as MockPool, f as MockReplyChain, M as MswAdapter, O as OnUnhandledRequest, P as PendingInterceptor, j as ReplyCallback, g as ReplyOptions, i as SetupServerLike, k as SingleReplyCallback, l as SingleReplyResult } from './fetch-mock-DhiqmHdF.js';

package/dist/index.js

@@ -1 +1,19 @@
-export { FetchMock, NodeMswAdapter, createFetchMock, fetchMock, MockCallHistory, MockCallHistoryLog, } from './node';
+import {
+  NodeMswAdapter,
+  createFetchMock,
+  fetchMock
+} from "./chunk-PUVZ7LB4.js";
+import "./chunk-IOGQ34QL.js";
+import {
+  FetchMock,
+  MockCallHistory,
+  MockCallHistoryLog
+} from "./chunk-3RAWYKAG.js";
+export {
+  FetchMock,
+  MockCallHistory,
+  MockCallHistoryLog,
+  NodeMswAdapter,
+  createFetchMock,
+  fetchMock
+};

package/dist/legacy.cjs

@@ -0,0 +1,71 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkN6B7UP6Bcjs = require('./chunk-N6B7UP6B.cjs');
+
+// src/legacy-handler-factory.ts
+function createLegacyHandlerFactory(rest) {
+  const methods = {
+    GET: rest.get,
+    POST: rest.post,
+    PUT: rest.put,
+    DELETE: rest.delete,
+    PATCH: rest.patch
+  };
+  return {
+    createHandler(method, urlPattern, handlerFn) {
+      return methods[method](urlPattern, async (req, res, ctx) => {
+        const headers = new Headers(req.headers.all());
+        const hasBody = !["GET", "HEAD"].includes(req.method);
+        const body = hasBody && req.body != null ? typeof req.body === "string" ? req.body : JSON.stringify(req.body) : void 0;
+        const request = new Request(req.url.toString(), {
+          method: req.method,
+          headers,
+          body
+        });
+        const response = await handlerFn(request);
+        if (!response) return void 0;
+        if (response.type === "error") {
+          return res.networkError("Failed to fetch");
+        }
+        const transformers = [ctx.status(response.status)];
+        response.headers.forEach((value, key) => {
+          transformers.push(ctx.set(key, value));
+        });
+        const text = await response.text();
+        if (text) {
+          transformers.push(ctx.body(text));
+        }
+        return res(...transformers);
+      });
+    },
+    buildResponse(status, body, headers) {
+      if (body === null || body === void 0) {
+        return new Response(null, { status, headers });
+      }
+      const responseHeaders = new Headers(headers);
+      responseHeaders.set("content-type", "application/json");
+      return new Response(JSON.stringify(body), { status, headers: responseHeaders });
+    },
+    buildErrorResponse() {
+      return Response.error();
+    }
+  };
+}
+
+// src/legacy.ts
+function createFetchMock(rest, server) {
+  _chunkN6B7UP6Bcjs.FetchMock._handlerFactory = createLegacyHandlerFactory(rest);
+  if (server) {
+    return new (0, _chunkN6B7UP6Bcjs.FetchMock)(server);
+  }
+  return new (0, _chunkN6B7UP6Bcjs.FetchMock)();
+}
+
+
+
+
+
+
+exports.FetchMock = _chunkN6B7UP6Bcjs.FetchMock; exports.MockCallHistory = _chunkN6B7UP6Bcjs.MockCallHistory; exports.MockCallHistoryLog = _chunkN6B7UP6Bcjs.MockCallHistoryLog; exports.createFetchMock = createFetchMock; exports.createLegacyHandlerFactory = createLegacyHandlerFactory;

package/dist/legacy.d.cts

@@ -0,0 +1,38 @@
+import { h as HttpMethod, H as HandlerFactory, i as SetupServerLike, F as FetchMock } from './fetch-mock-DhiqmHdF.cjs';
+export { A as ActivateOptions, C as CallHistoryFilterCriteria, I as InterceptOptions, a as MockCallHistory, b as MockCallHistoryLog, c as MockCallHistoryLogData, d as MockInterceptor, e as MockPool, f as MockReplyChain, M as MswAdapter, O as OnUnhandledRequest, P as PendingInterceptor, g as ReplyOptions } from './fetch-mock-DhiqmHdF.cjs';
+
+/** Duck-typed interface for MSW v1's `rest` API methods */
+type LegacyRestMethod = (url: string | RegExp, resolver: (req: any, res: any, ctx: any) => any) => unknown;
+/** Duck-typed interface for MSW v1's `rest` namespace */
+type LegacyRestApi = Record<Lowercase<HttpMethod>, LegacyRestMethod>;
+/**
+ * Creates a HandlerFactory for MSW v1 (legacy) API.
+ *
+ * MSW v1 uses `rest.get(url, (req, res, ctx) => res(ctx.json(data)))` style.
+ * This factory bridges the standard Request/Response interface used by FetchMock
+ * to the v1 resolver callback format.
+ *
+ * @param rest - The `rest` object from `msw` v1 (e.g., `import { rest } from 'msw'`)
+ */
+declare function createLegacyHandlerFactory(rest: LegacyRestApi): HandlerFactory;
+
+/**
+ * Create a FetchMock instance for MSW v1 (legacy) environments.
+ *
+ * Usage with MSW v1:
+ * ```ts
+ * import { rest } from 'msw';
+ * import { setupServer } from 'msw/node';
+ * import { createFetchMock } from 'msw-fetch-mock/legacy';
+ *
+ * const server = setupServer();
+ * const fetchMock = createFetchMock(rest, server);
+ * ```
+ *
+ * @param rest - The `rest` object from MSW v1 (`import { rest } from 'msw'`)
+ * @param server - Optional MSW v1 setupServer instance. If omitted, you must pass a
+ *   server or adapter to `new FetchMock(server)` yourself.
+ */
+declare function createFetchMock(rest: LegacyRestApi, server?: SetupServerLike): FetchMock;
+
+export { FetchMock, HandlerFactory, type LegacyRestApi, SetupServerLike, createFetchMock, createLegacyHandlerFactory };

package/dist/legacy.d.ts

@@ -0,0 +1,38 @@
+import { h as HttpMethod, H as HandlerFactory, i as SetupServerLike, F as FetchMock } from './fetch-mock-DhiqmHdF.js';
+export { A as ActivateOptions, C as CallHistoryFilterCriteria, I as InterceptOptions, a as MockCallHistory, b as MockCallHistoryLog, c as MockCallHistoryLogData, d as MockInterceptor, e as MockPool, f as MockReplyChain, M as MswAdapter, O as OnUnhandledRequest, P as PendingInterceptor, g as ReplyOptions } from './fetch-mock-DhiqmHdF.js';
+
+/** Duck-typed interface for MSW v1's `rest` API methods */
+type LegacyRestMethod = (url: string | RegExp, resolver: (req: any, res: any, ctx: any) => any) => unknown;
+/** Duck-typed interface for MSW v1's `rest` namespace */
+type LegacyRestApi = Record<Lowercase<HttpMethod>, LegacyRestMethod>;
+/**
+ * Creates a HandlerFactory for MSW v1 (legacy) API.
+ *
+ * MSW v1 uses `rest.get(url, (req, res, ctx) => res(ctx.json(data)))` style.
+ * This factory bridges the standard Request/Response interface used by FetchMock
+ * to the v1 resolver callback format.
+ *
+ * @param rest - The `rest` object from `msw` v1 (e.g., `import { rest } from 'msw'`)
+ */
+declare function createLegacyHandlerFactory(rest: LegacyRestApi): HandlerFactory;
+
+/**
+ * Create a FetchMock instance for MSW v1 (legacy) environments.
+ *
+ * Usage with MSW v1:
+ * ```ts
+ * import { rest } from 'msw';
+ * import { setupServer } from 'msw/node';
+ * import { createFetchMock } from 'msw-fetch-mock/legacy';
+ *
+ * const server = setupServer();
+ * const fetchMock = createFetchMock(rest, server);
+ * ```
+ *
+ * @param rest - The `rest` object from MSW v1 (`import { rest } from 'msw'`)
+ * @param server - Optional MSW v1 setupServer instance. If omitted, you must pass a
+ *   server or adapter to `new FetchMock(server)` yourself.
+ */
+declare function createFetchMock(rest: LegacyRestApi, server?: SetupServerLike): FetchMock;
+
+export { FetchMock, HandlerFactory, type LegacyRestApi, SetupServerLike, createFetchMock, createLegacyHandlerFactory };

package/dist/legacy.js

@@ -0,0 +1,71 @@
+import {
+  FetchMock,
+  MockCallHistory,
+  MockCallHistoryLog
+} from "./chunk-3RAWYKAG.js";
+
+// src/legacy-handler-factory.ts
+function createLegacyHandlerFactory(rest) {
+  const methods = {
+    GET: rest.get,
+    POST: rest.post,
+    PUT: rest.put,
+    DELETE: rest.delete,
+    PATCH: rest.patch
+  };
+  return {
+    createHandler(method, urlPattern, handlerFn) {
+      return methods[method](urlPattern, async (req, res, ctx) => {
+        const headers = new Headers(req.headers.all());
+        const hasBody = !["GET", "HEAD"].includes(req.method);
+        const body = hasBody && req.body != null ? typeof req.body === "string" ? req.body : JSON.stringify(req.body) : void 0;
+        const request = new Request(req.url.toString(), {
+          method: req.method,
+          headers,
+          body
+        });
+        const response = await handlerFn(request);
+        if (!response) return void 0;
+        if (response.type === "error") {
+          return res.networkError("Failed to fetch");
+        }
+        const transformers = [ctx.status(response.status)];
+        response.headers.forEach((value, key) => {
+          transformers.push(ctx.set(key, value));
+        });
+        const text = await response.text();
+        if (text) {
+          transformers.push(ctx.body(text));
+        }
+        return res(...transformers);
+      });
+    },
+    buildResponse(status, body, headers) {
+      if (body === null || body === void 0) {
+        return new Response(null, { status, headers });
+      }
+      const responseHeaders = new Headers(headers);
+      responseHeaders.set("content-type", "application/json");
+      return new Response(JSON.stringify(body), { status, headers: responseHeaders });
+    },
+    buildErrorResponse() {
+      return Response.error();
+    }
+  };
+}
+
+// src/legacy.ts
+function createFetchMock(rest, server) {
+  FetchMock._handlerFactory = createLegacyHandlerFactory(rest);
+  if (server) {
+    return new FetchMock(server);
+  }
+  return new FetchMock();
+}
+export {
+  FetchMock,
+  MockCallHistory,
+  MockCallHistoryLog,
+  createFetchMock,
+  createLegacyHandlerFactory
+};