msw-fetch-mock 0.3.0 → 0.3.2

package/dist/chunk-3RAWYKAG.js

@@ -0,0 +1,551 @@
+// src/mock-call-history.ts
+var MockCallHistoryLog = class {
+  body;
+  method;
+  headers;
+  fullUrl;
+  origin;
+  path;
+  searchParams;
+  protocol;
+  host;
+  port;
+  hash;
+  constructor(data) {
+    this.body = data.body;
+    this.method = data.method;
+    this.headers = data.headers;
+    this.fullUrl = data.fullUrl;
+    this.origin = data.origin;
+    this.path = data.path;
+    this.searchParams = data.searchParams;
+    this.protocol = data.protocol;
+    this.host = data.host;
+    this.port = data.port;
+    this.hash = data.hash;
+  }
+  json() {
+    if (this.body === null) return null;
+    return JSON.parse(this.body);
+  }
+  toMap() {
+    return /* @__PURE__ */ new Map([
+      ["body", this.body],
+      ["method", this.method],
+      ["headers", this.headers],
+      ["fullUrl", this.fullUrl],
+      ["origin", this.origin],
+      ["path", this.path],
+      ["searchParams", this.searchParams],
+      ["protocol", this.protocol],
+      ["host", this.host],
+      ["port", this.port],
+      ["hash", this.hash]
+    ]);
+  }
+  toString() {
+    return [
+      `method->${this.method}`,
+      `protocol->${this.protocol}`,
+      `host->${this.host}`,
+      `port->${this.port}`,
+      `origin->${this.origin}`,
+      `path->${this.path}`,
+      `hash->${this.hash}`,
+      `fullUrl->${this.fullUrl}`
+    ].join("|");
+  }
+};
+var MockCallHistory = class {
+  logs = [];
+  get length() {
+    return this.logs.length;
+  }
+  record(data) {
+    this.logs.push(data instanceof MockCallHistoryLog ? data : new MockCallHistoryLog(data));
+  }
+  called(criteria) {
+    if (criteria === void 0) return this.logs.length > 0;
+    return this.filterCalls(criteria).length > 0;
+  }
+  calls() {
+    return [...this.logs];
+  }
+  firstCall(criteria) {
+    if (criteria === void 0) return this.logs[0];
+    return this.filterCalls(criteria)[0];
+  }
+  lastCall(criteria) {
+    if (criteria === void 0) return this.logs[this.logs.length - 1];
+    const filtered = this.filterCalls(criteria);
+    return filtered[filtered.length - 1];
+  }
+  nthCall(n, criteria) {
+    if (criteria === void 0) return this.logs[n - 1];
+    return this.filterCalls(criteria)[n - 1];
+  }
+  clear() {
+    this.logs = [];
+  }
+  [Symbol.iterator]() {
+    return this.logs[Symbol.iterator]();
+  }
+  filterCalls(criteria, options) {
+    if (typeof criteria === "function") {
+      return this.logs.filter(criteria);
+    }
+    if (criteria instanceof RegExp) {
+      return this.logs.filter((log) => criteria.test(log.toString()));
+    }
+    const operator = options?.operator ?? "OR";
+    const keys = Object.keys(criteria);
+    const predicates = keys.filter((key) => criteria[key] !== void 0).map((key) => (log) => log[key] === criteria[key]);
+    if (predicates.length === 0) return [...this.logs];
+    return this.logs.filter(
+      (log) => operator === "AND" ? predicates.every((p) => p(log)) : predicates.some((p) => p(log))
+    );
+  }
+  filterBy(field, filter) {
+    return this.logs.filter(
+      (log) => typeof filter === "string" ? log[field] === filter : filter.test(String(log[field]))
+    );
+  }
+  filterCallsByMethod(filter) {
+    return this.filterBy("method", filter);
+  }
+  filterCallsByPath(filter) {
+    return this.filterBy("path", filter);
+  }
+  filterCallsByOrigin(filter) {
+    return this.filterBy("origin", filter);
+  }
+  filterCallsByProtocol(filter) {
+    return this.filterBy("protocol", filter);
+  }
+  filterCallsByHost(filter) {
+    return this.filterBy("host", filter);
+  }
+  filterCallsByPort(filter) {
+    return this.filterBy("port", filter);
+  }
+  filterCallsByHash(filter) {
+    return this.filterBy("hash", filter);
+  }
+  filterCallsByFullUrl(filter) {
+    return this.filterBy("fullUrl", filter);
+  }
+};
+
+// src/matchers.ts
+function isPending(p) {
+  if (p.persist) return p.timesInvoked === 0;
+  return p.timesInvoked < p.times;
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchesValue(value, matcher) {
+  if (typeof matcher === "string") return value === matcher;
+  if (matcher instanceof RegExp) return matcher.test(value);
+  return matcher(value);
+}
+function matchPath(request, origin, pathMatcher) {
+  if (typeof pathMatcher === "string") return true;
+  const url = new URL(request.url);
+  const originPrefix = new URL(origin).pathname.replace(/\/$/, "");
+  const fullPath = url.pathname + url.search;
+  const relativePath = fullPath.startsWith(originPrefix) ? fullPath.slice(originPrefix.length) : fullPath;
+  return matchesValue(relativePath, pathMatcher);
+}
+function matchQuery(request, query) {
+  if (!query) return true;
+  const url = new URL(request.url);
+  for (const [key, value] of Object.entries(query)) {
+    if (url.searchParams.get(key) !== value) return false;
+  }
+  return true;
+}
+function matchHeaders(request, headers) {
+  if (!headers) return true;
+  for (const [key, matcher] of Object.entries(headers)) {
+    const value = request.headers.get(key);
+    if (value === null || !matchesValue(value, matcher)) return false;
+  }
+  return true;
+}
+function matchBody(bodyText, bodyMatcher) {
+  if (!bodyMatcher) return true;
+  return matchesValue(bodyText ?? "", bodyMatcher);
+}
+function recordCall(callHistory, request, bodyText) {
+  const url = new URL(request.url);
+  const requestHeaders = {};
+  request.headers.forEach((value, key) => {
+    requestHeaders[key] = value;
+  });
+  const searchParams = {};
+  url.searchParams.forEach((value, key) => {
+    searchParams[key] = value;
+  });
+  callHistory.record({
+    body: bodyText,
+    method: request.method,
+    headers: requestHeaders,
+    fullUrl: url.origin + url.pathname + url.search,
+    origin: url.origin,
+    path: url.pathname,
+    searchParams,
+    protocol: url.protocol,
+    host: url.host,
+    port: url.port,
+    hash: url.hash
+  });
+}
+
+// src/type-guards.ts
+function isSetupServerLike(input) {
+  return typeof input === "object" && input !== null && "listen" in input && typeof input.listen === "function" && "close" in input && typeof input.close === "function";
+}
+function isSetupWorkerLike(input) {
+  return typeof input === "object" && input !== null && "start" in input && typeof input.start === "function" && "stop" in input && typeof input.stop === "function";
+}
+function isMswAdapter(input) {
+  return typeof input === "object" && input !== null && "activate" in input && typeof input.activate === "function" && "deactivate" in input && typeof input.deactivate === "function";
+}
+
+// src/fetch-mock.ts
+function createServerAdapter(server) {
+  return {
+    use: (...handlers) => server.use(...handlers),
+    resetHandlers: (...handlers) => server.resetHandlers(...handlers),
+    activate(options) {
+      server.listen({ onUnhandledRequest: options.onUnhandledRequest });
+    },
+    deactivate() {
+      server.close();
+    }
+  };
+}
+function createWorkerAdapter(worker) {
+  return {
+    use: (...handlers) => worker.use(...handlers),
+    resetHandlers: (...handlers) => worker.resetHandlers(...handlers),
+    async activate(options) {
+      await worker.start({ onUnhandledRequest: options.onUnhandledRequest });
+    },
+    deactivate() {
+      worker.stop();
+    }
+  };
+}
+function resolveAdapter(input) {
+  if (!input) {
+    if (!FetchMock._defaultAdapterFactory) {
+      throw new Error(
+        "FetchMock requires a server, worker, or adapter argument. Use createFetchMock() from msw-fetch-mock/node or msw-fetch-mock/browser, or pass a setupServer/setupWorker instance directly."
+      );
+    }
+    return FetchMock._defaultAdapterFactory();
+  }
+  if (isMswAdapter(input)) return input;
+  if (isSetupServerLike(input)) return createServerAdapter(input);
+  if (isSetupWorkerLike(input)) return createWorkerAdapter(input);
+  throw new Error("Invalid argument: expected a setupServer, setupWorker, or MswAdapter instance.");
+}
+var FetchMock = class _FetchMock {
+  /** @internal */
+  static _defaultAdapterFactory;
+  /** @internal */
+  static _handlerFactory;
+  get handlerFactory() {
+    if (!_FetchMock._handlerFactory) {
+      throw new Error(
+        "Handler factory not registered. Import from msw-fetch-mock/node or msw-fetch-mock/browser."
+      );
+    }
+    return _FetchMock._handlerFactory;
+  }
+  buildResponse(status, responseBody, replyOptions, defaultHeaders, addContentLength) {
+    const mergedHeaders = { ...defaultHeaders };
+    if (replyOptions?.headers) {
+      Object.assign(mergedHeaders, replyOptions.headers);
+    }
+    if (addContentLength && responseBody !== null && responseBody !== void 0) {
+      mergedHeaders["Content-Length"] = String(JSON.stringify(responseBody).length);
+    }
+    const headers = Object.keys(mergedHeaders).length > 0 ? new Headers(mergedHeaders) : void 0;
+    return this.handlerFactory.buildResponse(status, responseBody, headers);
+  }
+  _calls = new MockCallHistory();
+  adapter;
+  interceptors = [];
+  netConnectAllowed = false;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  mswHandlers = /* @__PURE__ */ new Map();
+  _defaultReplyHeaders = {};
+  _callHistoryEnabled = true;
+  get calls() {
+    return this._calls;
+  }
+  constructor(input) {
+    this.adapter = resolveAdapter(input);
+  }
+  async activate(options) {
+    const mode = options?.onUnhandledRequest ?? "error";
+    await this.adapter.activate({
+      onUnhandledRequest: (request, print) => {
+        if (this.isNetConnectAllowed(request)) return;
+        if (typeof mode === "function") {
+          mode(request, print);
+        } else if (mode === "error") {
+          print.error();
+        } else if (mode === "warn") {
+          print.warning();
+        }
+      }
+    });
+  }
+  disableNetConnect() {
+    this.netConnectAllowed = false;
+  }
+  enableNetConnect(matcher) {
+    this.netConnectAllowed = matcher ?? true;
+  }
+  isNetConnectAllowed(request) {
+    if (this.netConnectAllowed === true) return true;
+    if (this.netConnectAllowed === false) return false;
+    const host = new URL(request.url).host;
+    if (typeof this.netConnectAllowed === "string") return host === this.netConnectAllowed;
+    if (this.netConnectAllowed instanceof RegExp) return this.netConnectAllowed.test(host);
+    return this.netConnectAllowed(host);
+  }
+  /**
+   * Remove consumed MSW handlers so future requests to those URLs
+   * go through MSW's onUnhandledRequest instead of silently passing through.
+   */
+  syncMswHandlers() {
+    const activeHandlers = [...this.mswHandlers.entries()].filter(([p]) => !p.consumed || p.persist).map(([, handler]) => handler);
+    this.adapter.resetHandlers(...activeHandlers);
+  }
+  getCallHistory() {
+    return this._calls;
+  }
+  clearCallHistory() {
+    this._calls.clear();
+  }
+  clearAllCallHistory() {
+    this.clearCallHistory();
+  }
+  defaultReplyHeaders(headers) {
+    this._defaultReplyHeaders = headers;
+  }
+  enableCallHistory() {
+    this._callHistoryEnabled = true;
+  }
+  disableCallHistory() {
+    this._callHistoryEnabled = false;
+  }
+  deactivate() {
+    this.interceptors = [];
+    this.mswHandlers.clear();
+    this._calls.clear();
+    this.adapter.deactivate();
+  }
+  reset() {
+    this.interceptors = [];
+    this.mswHandlers.clear();
+    this._calls.clear();
+    this._defaultReplyHeaders = {};
+    this.adapter.resetHandlers();
+  }
+  assertNoPendingInterceptors() {
+    const unconsumed = this.interceptors.filter(isPending);
+    if (unconsumed.length > 0) {
+      const descriptions = unconsumed.map((p) => `  ${p.method} ${p.origin}${p.path}`);
+      throw new Error(`Pending interceptor(s) not consumed:
+${descriptions.join("\n")}`);
+    }
+  }
+  pendingInterceptors() {
+    return this.interceptors.filter(isPending).map((p) => ({ ...p }));
+  }
+  resolveUrlPattern(origin, path) {
+    if (typeof origin === "string") {
+      return typeof path === "string" ? `${origin}${path}` : new RegExp(`^${escapeRegExp(origin)}`);
+    }
+    return /.*/;
+  }
+  matchOriginAndPath(request, origin, originStr, path) {
+    if (typeof origin === "string") {
+      return matchPath(request, originStr, path);
+    }
+    const url = new URL(request.url);
+    if (origin instanceof RegExp ? !origin.test(url.origin) : !origin(url.origin)) {
+      return false;
+    }
+    if (typeof path === "string") {
+      return url.pathname === path || url.pathname.endsWith(path);
+    }
+    const fullPath = url.pathname + url.search;
+    return matchesValue(fullPath, path);
+  }
+  async matchAndConsume(request, pending, origin, originStr, options) {
+    if (!pending.persist && pending.timesInvoked >= pending.times) return;
+    if (!this.matchOriginAndPath(request, origin, originStr, options.path)) return;
+    if (!matchQuery(request, options.query)) return;
+    if (!matchHeaders(request, options.headers)) return;
+    const bodyText = await request.text() || null;
+    if (!matchBody(bodyText, options.body)) return;
+    pending.timesInvoked++;
+    if (!pending.persist && pending.timesInvoked >= pending.times) {
+      pending.consumed = true;
+      this.syncMswHandlers();
+    }
+    if (this._callHistoryEnabled) {
+      recordCall(this._calls, request, bodyText);
+    }
+    return bodyText;
+  }
+  registerHandler(pending, method, urlPattern, handlerFn) {
+    const handler = this.handlerFactory.createHandler(method, urlPattern, handlerFn);
+    this.mswHandlers.set(pending, handler);
+    this.adapter.use(handler);
+  }
+  createMatchingHandler(pending, origin, originStr, options, delayRef, respond) {
+    return async (request) => {
+      const bodyText = await this.matchAndConsume(request, pending, origin, originStr, options);
+      if (bodyText === void 0) return;
+      if (delayRef.ms > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delayRef.ms));
+      }
+      return respond(bodyText);
+    };
+  }
+  buildChain(pending, delayRef, contentLengthRef) {
+    return {
+      times(n) {
+        pending.times = n;
+        pending.consumed = false;
+      },
+      persist() {
+        pending.persist = true;
+        pending.consumed = false;
+      },
+      delay(ms) {
+        delayRef.ms = ms;
+      },
+      replyContentLength() {
+        contentLengthRef.enabled = true;
+      }
+    };
+  }
+  get(origin) {
+    const originStr = typeof origin === "string" ? origin : origin instanceof RegExp ? origin.toString() : "<function>";
+    return {
+      intercept: (options) => {
+        const method = options.method ?? "GET";
+        const pathStr = typeof options.path === "string" ? options.path : typeof options.path === "function" ? "<function>" : options.path.toString();
+        const pending = {
+          origin: originStr,
+          path: pathStr,
+          method,
+          consumed: false,
+          times: 1,
+          timesInvoked: 0,
+          persist: false
+        };
+        this.interceptors.push(pending);
+        const urlPattern = this.resolveUrlPattern(origin, options.path);
+        return {
+          reply: (statusOrCallback, bodyOrCallback, replyOptions) => {
+            const delayRef = { ms: 0 };
+            const contentLengthRef = { enabled: false };
+            if (typeof statusOrCallback === "function") {
+              const callback = statusOrCallback;
+              this.registerHandler(
+                pending,
+                method,
+                urlPattern,
+                this.createMatchingHandler(
+                  pending,
+                  origin,
+                  originStr,
+                  options,
+                  delayRef,
+                  async (bodyText) => {
+                    const result = await callback({ body: bodyText });
+                    return this.buildResponse(
+                      result.statusCode,
+                      result.data,
+                      result.responseOptions,
+                      this._defaultReplyHeaders,
+                      contentLengthRef.enabled
+                    );
+                  }
+                )
+              );
+            } else {
+              const status = statusOrCallback;
+              this.registerHandler(
+                pending,
+                method,
+                urlPattern,
+                this.createMatchingHandler(
+                  pending,
+                  origin,
+                  originStr,
+                  options,
+                  delayRef,
+                  async (bodyText) => {
+                    let responseBody;
+                    if (typeof bodyOrCallback === "function") {
+                      responseBody = await bodyOrCallback({
+                        body: bodyText
+                      });
+                    } else {
+                      responseBody = bodyOrCallback;
+                    }
+                    return this.buildResponse(
+                      status,
+                      responseBody,
+                      replyOptions,
+                      this._defaultReplyHeaders,
+                      contentLengthRef.enabled
+                    );
+                  }
+                )
+              );
+            }
+            return this.buildChain(pending, delayRef, contentLengthRef);
+          },
+          replyWithError: () => {
+            const delayRef = { ms: 0 };
+            const contentLengthRef = { enabled: false };
+            this.registerHandler(
+              pending,
+              method,
+              urlPattern,
+              this.createMatchingHandler(
+                pending,
+                origin,
+                originStr,
+                options,
+                delayRef,
+                async () => {
+                  return this.handlerFactory.buildErrorResponse();
+                }
+              )
+            );
+            return this.buildChain(pending, delayRef, contentLengthRef);
+          }
+        };
+      }
+    };
+  }
+};
+
+export {
+  MockCallHistoryLog,
+  MockCallHistory,
+  FetchMock
+};

package/dist/chunk-IOGQ34QL.js

@@ -0,0 +1,27 @@
+// src/http-handler-factory.ts
+import { http, HttpResponse } from "msw";
+var methods = {
+  GET: http.get,
+  POST: http.post,
+  PUT: http.put,
+  DELETE: http.delete,
+  PATCH: http.patch
+};
+var httpHandlerFactory = {
+  createHandler(method, urlPattern, handlerFn) {
+    return methods[method](urlPattern, async ({ request }) => handlerFn(request));
+  },
+  buildResponse(status, body, headers) {
+    if (body === null || body === void 0) {
+      return new HttpResponse(null, { status, headers });
+    }
+    return HttpResponse.json(body, { status, headers });
+  },
+  buildErrorResponse() {
+    return HttpResponse.error();
+  }
+};
+
+export {
+  httpHandlerFactory
+};