msw-fetch-mock 0.2.1 → 0.3.1

package/dist/chunk-43CWIVXO.cjs

@@ -0,0 +1,540 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;// src/mock-call-history.ts
+var MockCallHistoryLog = class {
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  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 = class {constructor() { _class.prototype.__init.call(this); }
+  __init() {this.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 = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.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);
+  }
+}, _class);
+
+// 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(_nullishCoalesce(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 = (_class2 = class _FetchMock {
+  /** @internal */
+  
+  /** @internal */
+  
+  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 (_optionalChain([replyOptions, 'optionalAccess', _2 => _2.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);
+  }
+  __init2() {this._calls = new MockCallHistory()}
+  
+  __init3() {this.interceptors = []}
+  __init4() {this.netConnectAllowed = false}
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  __init5() {this.mswHandlers = /* @__PURE__ */ new Map()}
+  __init6() {this._defaultReplyHeaders = {}}
+  __init7() {this._callHistoryEnabled = true}
+  get calls() {
+    return this._calls;
+  }
+  constructor(input) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);
+    this.adapter = resolveAdapter(input);
+  }
+  async activate(options) {
+    const mode = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _3 => _3.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 = _nullishCoalesce(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 /.*/;
+  }
+  matchOrigin(request, origin) {
+    if (typeof origin === "string") return true;
+    const url = new URL(request.url);
+    if (origin instanceof RegExp) return origin.test(url.origin);
+    return origin(url.origin);
+  }
+  matchPathForOrigin(request, origin, originStr, path) {
+    if (typeof origin !== "string") {
+      if (typeof path === "string") {
+        const url2 = new URL(request.url);
+        return url2.pathname === path || url2.pathname.endsWith(path);
+      }
+      const url = new URL(request.url);
+      const fullPath = url.pathname + url.search;
+      return matchesValue(fullPath, path);
+    }
+    return matchPath(request, originStr, path);
+  }
+  async matchAndConsume(request, pending, origin, originStr, options) {
+    if (!pending.persist && pending.timesInvoked >= pending.times) return;
+    if (!this.matchOrigin(request, origin)) return;
+    if (!this.matchPathForOrigin(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);
+  }
+  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 = _nullishCoalesce(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, 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));
+                }
+                const result = await callback({ body: bodyText || null });
+                return this.buildResponse(
+                  result.statusCode,
+                  result.data,
+                  result.responseOptions,
+                  this._defaultReplyHeaders,
+                  contentLengthRef.enabled
+                );
+              });
+            } else {
+              const status = statusOrCallback;
+              this.registerHandler(pending, method, urlPattern, 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));
+                }
+                let responseBody;
+                if (typeof bodyOrCallback === "function") {
+                  responseBody = await bodyOrCallback({
+                    body: bodyText || null
+                  });
+                } 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, async (request) => {
+              const bodyText = await this.matchAndConsume(
+                request,
+                pending,
+                origin,
+                originStr,
+                options
+              );
+              if (bodyText === void 0) return;
+              return this.handlerFactory.buildErrorResponse();
+            });
+            return this.buildChain(pending, delayRef, contentLengthRef);
+          }
+        };
+      }
+    };
+  }
+}, _class2);
+
+
+
+
+
+exports.MockCallHistoryLog = MockCallHistoryLog; exports.MockCallHistory = MockCallHistory; exports.FetchMock = FetchMock;

package/dist/chunk-A56K5DPD.cjs

@@ -0,0 +1,58 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkHYRDB2FHcjs = require('./chunk-HYRDB2FH.cjs');
+
+
+var _chunk43CWIVXOcjs = require('./chunk-43CWIVXO.cjs');
+
+// src/node-adapter.ts
+var _node = require('msw/node');
+var NodeMswAdapter = class {
+  
+  
+  constructor(externalServer) {
+    this.server = _nullishCoalesce(externalServer, () => ( null));
+    this.ownsServer = !externalServer;
+  }
+  use(...handlers) {
+    this.server.use(...handlers);
+  }
+  resetHandlers(...handlers) {
+    this.server.resetHandlers(...handlers);
+  }
+  activate(options) {
+    if (!this.ownsServer) return;
+    const isPatched = Object.getOwnPropertySymbols(globalThis.fetch).some(
+      (s) => s.description === "isPatchedModule"
+    );
+    if (isPatched) {
+      throw new Error(
+        "Another MSW server is already active. Pass your existing server to new FetchMock(server) instead."
+      );
+    }
+    this.server = _node.setupServer.call(void 0, );
+    this.server.listen({
+      onUnhandledRequest: options.onUnhandledRequest
+    });
+  }
+  deactivate() {
+    if (this.ownsServer) {
+      _optionalChain([this, 'access', _ => _.server, 'optionalAccess', _2 => _2.close, 'call', _3 => _3()]);
+      this.server = null;
+    }
+  }
+};
+
+// src/node.ts
+_chunk43CWIVXOcjs.FetchMock._defaultAdapterFactory = () => new NodeMswAdapter();
+_chunk43CWIVXOcjs.FetchMock._handlerFactory = _chunkHYRDB2FHcjs.v2HandlerFactory;
+function createFetchMock(server) {
+  return new (0, _chunk43CWIVXOcjs.FetchMock)(new NodeMswAdapter(server));
+}
+var fetchMock = createFetchMock();
+
+
+
+
+
+exports.NodeMswAdapter = NodeMswAdapter; exports.createFetchMock = createFetchMock; exports.fetchMock = fetchMock;