msw 2.12.13 → 2.13.0

package/lib/core/experimental/handlers-controller.mjs

@@ -0,0 +1,101 @@
+import { invariant } from "outvariant";
+import { devUtils } from '../utils/internal/devUtils.mjs';
+function groupHandlersByKind(handlers) {
+  const groups = {};
+  for (const handler of handlers) {
+    ;
+    (groups[handler.kind] ||= []).push(handler);
+  }
+  return groups;
+}
+class HandlersController {
+  getInitialState(initialHandlers) {
+    invariant(
+      this.#validateHandlers(initialHandlers),
+      devUtils.formatMessage(
+        "[MSW] Failed to apply given request handlers: invalid input. Did you forget to spread the request handlers Array?"
+      )
+    );
+    const normalizedInitialHandlers = groupHandlersByKind(initialHandlers);
+    return {
+      initialHandlers: normalizedInitialHandlers,
+      handlers: { ...normalizedInitialHandlers }
+    };
+  }
+  currentHandlers() {
+    return Object.values(this.getState().handlers).flat().filter((handler) => handler != null);
+  }
+  getHandlersByKind(kind) {
+    return this.getState().handlers[kind] || [];
+  }
+  use(nextHandlers) {
+    invariant(
+      this.#validateHandlers(nextHandlers),
+      devUtils.formatMessage(
+        '[MSW] Failed to call "use()" with the given request handlers: invalid input. Did you forget to spread the array of request handlers?'
+      )
+    );
+    if (nextHandlers.length === 0) {
+      return;
+    }
+    const { handlers } = this.getState();
+    for (let i = nextHandlers.length - 1; i >= 0; i--) {
+      const handler = nextHandlers[i];
+      handlers[handler.kind] = handlers[handler.kind] ? [handler, ...handlers[handler.kind]] : [handler];
+    }
+    this.setState({ handlers });
+  }
+  reset(nextHandlers) {
+    invariant(
+      nextHandlers.length > 0 ? this.#validateHandlers(nextHandlers) : true,
+      devUtils.formatMessage(
+        "Failed to replace initial handlers during reset: invalid handlers. Did you forget to spread the handlers array?"
+      )
+    );
+    const { initialHandlers } = this.getState();
+    if (nextHandlers.length === 0) {
+      this.setState({
+        handlers: { ...initialHandlers }
+      });
+      return;
+    }
+    const normalizedNextHandlers = groupHandlersByKind(nextHandlers);
+    this.setState({
+      initialHandlers: normalizedNextHandlers,
+      handlers: { ...normalizedNextHandlers }
+    });
+  }
+  #validateHandlers(handlers) {
+    return handlers.every((handler) => !Array.isArray(handler));
+  }
+}
+class InMemoryHandlersController extends HandlersController {
+  #handlers;
+  #initialHandlers;
+  constructor(initialHandlers) {
+    super();
+    const initialState = this.getInitialState(initialHandlers);
+    this.#initialHandlers = initialState.initialHandlers;
+    this.#handlers = initialState.handlers;
+  }
+  getState() {
+    return {
+      initialHandlers: this.#initialHandlers,
+      handlers: this.#handlers
+    };
+  }
+  setState(nextState) {
+    if (nextState.initialHandlers) {
+      this.#initialHandlers = nextState.initialHandlers;
+    }
+    if (nextState.handlers) {
+      this.#handlers = nextState.handlers;
+    }
+  }
+}
+export {
+  HandlersController,
+  InMemoryHandlersController,
+  groupHandlersByKind
+};
+//# sourceMappingURL=handlers-controller.mjs.map

package/lib/core/experimental/handlers-controller.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/experimental/handlers-controller.ts"],"sourcesContent":["import { invariant } from 'outvariant'\nimport { type RequestHandler } from '../handlers/RequestHandler'\nimport { type WebSocketHandler } from '../handlers/WebSocketHandler'\nimport { devUtils } from '../utils/internal/devUtils'\n\nexport type AnyHandler = RequestHandler | WebSocketHandler\nexport type HandlersMap = Partial<Record<AnyHandler['kind'], Array<AnyHandler>>>\n\nexport function groupHandlersByKind(handlers: Array<AnyHandler>): HandlersMap {\n  const groups: HandlersMap = {}\n\n  /**\n   * @note `Object.groupBy` is not implemented in Node.js v20.\n   */\n  for (const handler of handlers) {\n    ;(groups[handler.kind] ||= []).push(handler)\n  }\n\n  return groups\n}\n\nexport interface HandlersControllerState {\n  initialHandlers: HandlersMap\n  handlers: HandlersMap\n}\n\nexport abstract class HandlersController {\n  protected getInitialState(\n    initialHandlers: Array<AnyHandler>,\n  ): HandlersControllerState {\n    invariant(\n      this.#validateHandlers(initialHandlers),\n      devUtils.formatMessage(\n        '[MSW] Failed to apply given request handlers: invalid input. Did you forget to spread the request handlers Array?',\n      ),\n    )\n\n    const normalizedInitialHandlers = groupHandlersByKind(initialHandlers)\n\n    return {\n      initialHandlers: normalizedInitialHandlers,\n      handlers: { ...normalizedInitialHandlers },\n    }\n  }\n\n  protected abstract getState(): HandlersControllerState\n  protected abstract setState(nextState: Partial<HandlersControllerState>): void\n\n  public currentHandlers(): Array<AnyHandler> {\n    return Object.values(this.getState().handlers)\n      .flat()\n      .filter((handler) => handler != null)\n  }\n\n  public getHandlersByKind(kind: AnyHandler['kind']): Array<AnyHandler> {\n    return this.getState().handlers[kind] || []\n  }\n\n  public use(nextHandlers: Array<AnyHandler>): void {\n    invariant(\n      this.#validateHandlers(nextHandlers),\n      devUtils.formatMessage(\n        '[MSW] Failed to call \"use()\" with the given request handlers: invalid input. Did you forget to spread the array of request handlers?',\n      ),\n    )\n\n    if (nextHandlers.length === 0) {\n      return\n    }\n\n    const { handlers } = this.getState()\n\n    // Iterate over next handlers and prepend them to their respective lists.\n    // Iterate in a reverse order to the keep the order of the runtime handlers as provided.\n    for (let i = nextHandlers.length - 1; i >= 0; i--) {\n      const handler = nextHandlers[i]\n      handlers[handler.kind] = handlers[handler.kind]\n        ? [handler, ...handlers[handler.kind]!]\n        : [handler]\n    }\n\n    this.setState({ handlers })\n  }\n\n  public reset(nextHandlers: Array<AnyHandler>): void {\n    invariant(\n      nextHandlers.length > 0 ? this.#validateHandlers(nextHandlers) : true,\n      devUtils.formatMessage(\n        'Failed to replace initial handlers during reset: invalid handlers. Did you forget to spread the handlers array?',\n      ),\n    )\n\n    const { initialHandlers } = this.getState()\n\n    if (nextHandlers.length === 0) {\n      this.setState({\n        handlers: { ...initialHandlers },\n      })\n\n      return\n    }\n\n    const normalizedNextHandlers = groupHandlersByKind(nextHandlers)\n\n    this.setState({\n      initialHandlers: normalizedNextHandlers,\n      handlers: { ...normalizedNextHandlers },\n    })\n  }\n\n  #validateHandlers(handlers: Array<AnyHandler>): boolean {\n    return handlers.every((handler) => !Array.isArray(handler))\n  }\n}\n\nexport class InMemoryHandlersController extends HandlersController {\n  #handlers: HandlersMap\n  #initialHandlers: HandlersMap\n\n  constructor(initialHandlers: Array<AnyHandler>) {\n    super()\n\n    const initialState = this.getInitialState(initialHandlers)\n\n    this.#initialHandlers = initialState.initialHandlers\n    this.#handlers = initialState.handlers\n  }\n\n  protected getState(): HandlersControllerState {\n    return {\n      initialHandlers: this.#initialHandlers,\n      handlers: this.#handlers,\n    }\n  }\n\n  protected setState(nextState: Partial<HandlersControllerState>): void {\n    if (nextState.initialHandlers) {\n      this.#initialHandlers = nextState.initialHandlers\n    }\n\n    if (nextState.handlers) {\n      this.#handlers = nextState.handlers\n    }\n  }\n}\n"],"mappings":"AAAA,SAAS,iBAAiB;AAG1B,SAAS,gBAAgB;AAKlB,SAAS,oBAAoB,UAA0C;AAC5E,QAAM,SAAsB,CAAC;AAK7B,aAAW,WAAW,UAAU;AAC9B;AAAC,KAAC,OAAO,QAAQ,IAAI,MAAM,CAAC,GAAG,KAAK,OAAO;AAAA,EAC7C;AAEA,SAAO;AACT;AAOO,MAAe,mBAAmB;AAAA,EAC7B,gBACR,iBACyB;AACzB;AAAA,MACE,KAAK,kBAAkB,eAAe;AAAA,MACtC,SAAS;AAAA,QACP;AAAA,MACF;AAAA,IACF;AAEA,UAAM,4BAA4B,oBAAoB,eAAe;AAErE,WAAO;AAAA,MACL,iBAAiB;AAAA,MACjB,UAAU,EAAE,GAAG,0BAA0B;AAAA,IAC3C;AAAA,EACF;AAAA,EAKO,kBAAqC;AAC1C,WAAO,OAAO,OAAO,KAAK,SAAS,EAAE,QAAQ,EAC1C,KAAK,EACL,OAAO,CAAC,YAAY,WAAW,IAAI;AAAA,EACxC;AAAA,EAEO,kBAAkB,MAA6C;AACpE,WAAO,KAAK,SAAS,EAAE,SAAS,IAAI,KAAK,CAAC;AAAA,EAC5C;AAAA,EAEO,IAAI,cAAuC;AAChD;AAAA,MACE,KAAK,kBAAkB,YAAY;AAAA,MACnC,SAAS;AAAA,QACP;AAAA,MACF;AAAA,IACF;AAEA,QAAI,aAAa,WAAW,GAAG;AAC7B;AAAA,IACF;AAEA,UAAM,EAAE,SAAS,IAAI,KAAK,SAAS;AAInC,aAAS,IAAI,aAAa,SAAS,GAAG,KAAK,GAAG,KAAK;AACjD,YAAM,UAAU,aAAa,CAAC;AAC9B,eAAS,QAAQ,IAAI,IAAI,SAAS,QAAQ,IAAI,IAC1C,CAAC,SAAS,GAAG,SAAS,QAAQ,IAAI,CAAE,IACpC,CAAC,OAAO;AAAA,IACd;AAEA,SAAK,SAAS,EAAE,SAAS,CAAC;AAAA,EAC5B;AAAA,EAEO,MAAM,cAAuC;AAClD;AAAA,MACE,aAAa,SAAS,IAAI,KAAK,kBAAkB,YAAY,IAAI;AAAA,MACjE,SAAS;AAAA,QACP;AAAA,MACF;AAAA,IACF;AAEA,UAAM,EAAE,gBAAgB,IAAI,KAAK,SAAS;AAE1C,QAAI,aAAa,WAAW,GAAG;AAC7B,WAAK,SAAS;AAAA,QACZ,UAAU,EAAE,GAAG,gBAAgB;AAAA,MACjC,CAAC;AAED;AAAA,IACF;AAEA,UAAM,yBAAyB,oBAAoB,YAAY;AAE/D,SAAK,SAAS;AAAA,MACZ,iBAAiB;AAAA,MACjB,UAAU,EAAE,GAAG,uBAAuB;AAAA,IACxC,CAAC;AAAA,EACH;AAAA,EAEA,kBAAkB,UAAsC;AACtD,WAAO,SAAS,MAAM,CAAC,YAAY,CAAC,MAAM,QAAQ,OAAO,CAAC;AAAA,EAC5D;AACF;AAEO,MAAM,mCAAmC,mBAAmB;AAAA,EACjE;AAAA,EACA;AAAA,EAEA,YAAY,iBAAoC;AAC9C,UAAM;AAEN,UAAM,eAAe,KAAK,gBAAgB,eAAe;AAEzD,SAAK,mBAAmB,aAAa;AACrC,SAAK,YAAY,aAAa;AAAA,EAChC;AAAA,EAEU,WAAoC;AAC5C,WAAO;AAAA,MACL,iBAAiB,KAAK;AAAA,MACtB,UAAU,KAAK;AAAA,IACjB;AAAA,EACF;AAAA,EAEU,SAAS,WAAmD;AACpE,QAAI,UAAU,iBAAiB;AAC7B,WAAK,mBAAmB,UAAU;AAAA,IACpC;AAEA,QAAI,UAAU,UAAU;AACtB,WAAK,YAAY,UAAU;AAAA,IAC7B;AAAA,EACF;AACF;","names":[]}

package/lib/core/experimental/index.d.mts

@@ -0,0 +1,17 @@
+export { DefineNetworkOptions, defineNetwork } from './define-network.mjs';
+export { NetworkSource } from './sources/network-source.mjs';
+export { InterceptorSource } from './sources/interceptor-source.mjs';
+export { N as NetworkFrame } from '../network-frame-B7A0ggXE.mjs';
+export { HttpNetworkFrame, HttpNetworkFrameEventMap } from './frames/http-frame.mjs';
+export { WebSocketNetworkFrame, WebSocketNetworkFrameEventMap } from './frames/websocket-frame.mjs';
+import 'rettime';
+import './handlers-controller.mjs';
+import '../HttpResponse-DlRR1D-f.mjs';
+import '@mswjs/interceptors';
+import '../utils/internal/isIterable.mjs';
+import '../typeUtils.mjs';
+import 'graphql';
+import '../utils/matching/matchRequestUrl.mjs';
+import '../handlers/WebSocketHandler.mjs';
+import 'strict-event-emitter';
+import '@mswjs/interceptors/WebSocket';

package/lib/core/experimental/index.d.ts

@@ -0,0 +1,17 @@
+export { DefineNetworkOptions, defineNetwork } from './define-network.js';
+export { NetworkSource } from './sources/network-source.js';
+export { InterceptorSource } from './sources/interceptor-source.js';
+export { N as NetworkFrame } from '../network-frame-usYiHS0K.js';
+export { HttpNetworkFrame, HttpNetworkFrameEventMap } from './frames/http-frame.js';
+export { WebSocketNetworkFrame, WebSocketNetworkFrameEventMap } from './frames/websocket-frame.js';
+import 'rettime';
+import './handlers-controller.js';
+import '../HttpResponse-CksOMVAa.js';
+import '@mswjs/interceptors';
+import '../utils/internal/isIterable.js';
+import '../typeUtils.js';
+import 'graphql';
+import '../utils/matching/matchRequestUrl.js';
+import '../handlers/WebSocketHandler.js';
+import 'strict-event-emitter';
+import '@mswjs/interceptors/WebSocket';

package/lib/core/experimental/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var experimental_exports = {};
+__export(experimental_exports, {
+  DefineNetworkOptions: () => import_define_network.DefineNetworkOptions,
+  HttpNetworkFrame: () => import_http_frame.HttpNetworkFrame,
+  InterceptorSource: () => import_interceptor_source.InterceptorSource,
+  NetworkFrame: () => import_network_frame.NetworkFrame,
+  NetworkSource: () => import_network_source.NetworkSource,
+  WebSocketNetworkFrame: () => import_websocket_frame.WebSocketNetworkFrame,
+  defineNetwork: () => import_define_network.defineNetwork
+});
+module.exports = __toCommonJS(experimental_exports);
+var import_define_network = require("./define-network");
+var import_network_source = require("./sources/network-source");
+var import_interceptor_source = require("./sources/interceptor-source");
+var import_network_frame = require("./frames/network-frame");
+var import_http_frame = require("./frames/http-frame");
+var import_websocket_frame = require("./frames/websocket-frame");
+//# sourceMappingURL=index.js.map

package/lib/core/experimental/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/experimental/index.ts"],"sourcesContent":["export { defineNetwork, DefineNetworkOptions } from './define-network'\n\n/* Network sources */\nexport { NetworkSource } from './sources/network-source'\nexport { InterceptorSource } from './sources/interceptor-source'\n\n/* Frames */\nexport { NetworkFrame } from './frames/network-frame'\nexport {\n  HttpNetworkFrame,\n  type HttpNetworkFrameEventMap,\n} from './frames/http-frame'\nexport {\n  WebSocketNetworkFrame,\n  type WebSocketNetworkFrameEventMap,\n} from './frames/websocket-frame'\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAAoD;AAGpD,4BAA8B;AAC9B,gCAAkC;AAGlC,2BAA6B;AAC7B,wBAGO;AACP,6BAGO;","names":[]}

package/lib/core/experimental/index.mjs

@@ -0,0 +1,20 @@
+import { defineNetwork, DefineNetworkOptions } from './define-network.mjs';
+import { NetworkSource } from './sources/network-source.mjs';
+import { InterceptorSource } from './sources/interceptor-source.mjs';
+import { NetworkFrame } from './frames/network-frame.mjs';
+import {
+  HttpNetworkFrame
+} from './frames/http-frame.mjs';
+import {
+  WebSocketNetworkFrame
+} from './frames/websocket-frame.mjs';
+export {
+  DefineNetworkOptions,
+  HttpNetworkFrame,
+  InterceptorSource,
+  NetworkFrame,
+  NetworkSource,
+  WebSocketNetworkFrame,
+  defineNetwork
+};
+//# sourceMappingURL=index.mjs.map

package/lib/core/experimental/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/experimental/index.ts"],"sourcesContent":["export { defineNetwork, DefineNetworkOptions } from './define-network'\n\n/* Network sources */\nexport { NetworkSource } from './sources/network-source'\nexport { InterceptorSource } from './sources/interceptor-source'\n\n/* Frames */\nexport { NetworkFrame } from './frames/network-frame'\nexport {\n  HttpNetworkFrame,\n  type HttpNetworkFrameEventMap,\n} from './frames/http-frame'\nexport {\n  WebSocketNetworkFrame,\n  type WebSocketNetworkFrameEventMap,\n} from './frames/websocket-frame'\n"],"mappings":"AAAA,SAAS,eAAe,4BAA4B;AAGpD,SAAS,qBAAqB;AAC9B,SAAS,yBAAyB;AAGlC,SAAS,oBAAoB;AAC7B;AAAA,EACE;AAAA,OAEK;AACP;AAAA,EACE;AAAA,OAEK;","names":[]}

package/lib/core/experimental/on-unhandled-frame.d.mts

@@ -0,0 +1,12 @@
+export { U as UnhandledFrameCallback, d as UnhandledFrameDefaults, b as UnhandledFrameHandle, c as UnhandledFrameStrategy, e as executeUnhandledFrameHandle } from '../network-frame-B7A0ggXE.mjs';
+import 'rettime';
+import './handlers-controller.mjs';
+import '../HttpResponse-DlRR1D-f.mjs';
+import '@mswjs/interceptors';
+import '../utils/internal/isIterable.mjs';
+import '../typeUtils.mjs';
+import 'graphql';
+import '../utils/matching/matchRequestUrl.mjs';
+import '../handlers/WebSocketHandler.mjs';
+import 'strict-event-emitter';
+import '@mswjs/interceptors/WebSocket';

package/lib/core/experimental/on-unhandled-frame.d.ts

@@ -0,0 +1,12 @@
+export { U as UnhandledFrameCallback, d as UnhandledFrameDefaults, b as UnhandledFrameHandle, c as UnhandledFrameStrategy, e as executeUnhandledFrameHandle } from '../network-frame-usYiHS0K.js';
+import 'rettime';
+import './handlers-controller.js';
+import '../HttpResponse-CksOMVAa.js';
+import '@mswjs/interceptors';
+import '../utils/internal/isIterable.js';
+import '../typeUtils.js';
+import 'graphql';
+import '../utils/matching/matchRequestUrl.js';
+import '../handlers/WebSocketHandler.js';
+import 'strict-event-emitter';
+import '@mswjs/interceptors/WebSocket';

package/lib/core/experimental/on-unhandled-frame.js

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var on_unhandled_frame_exports = {};
+__export(on_unhandled_frame_exports, {
+  executeUnhandledFrameHandle: () => executeUnhandledFrameHandle
+});
+module.exports = __toCommonJS(on_unhandled_frame_exports);
+var import_outvariant = require("outvariant");
+var import_isCommonAssetRequest = require("../isCommonAssetRequest");
+var import_devUtils = require("../utils/internal/devUtils");
+var import_http_frame = require("./frames/http-frame");
+async function executeUnhandledFrameHandle(frame, handle) {
+  const printStrategyMessage = async (strategy) => {
+    if (strategy === "bypass") {
+      return;
+    }
+    const message = await frame.getUnhandledMessage();
+    switch (strategy) {
+      case "warn": {
+        return import_devUtils.devUtils.warn("Warning: %s", message);
+      }
+      case "error": {
+        return import_devUtils.devUtils.error("Error: %s", message);
+      }
+    }
+  };
+  const applyStrategy = async (strategy) => {
+    import_outvariant.invariant.as(
+      import_devUtils.InternalError,
+      strategy === "bypass" || strategy === "warn" || strategy === "error",
+      /**
+       * @fixme Rename "onUnhandledRequest" to "onUnhandledFrame" in the error message
+       * with the next major release.
+       */
+      import_devUtils.devUtils.formatMessage(
+        'Failed to react to an unhandled network frame: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
+        strategy
+      )
+    );
+    if (strategy === "bypass") {
+      return;
+    }
+    await printStrategyMessage(strategy);
+    if (strategy === "error") {
+      return Promise.reject(
+        new import_devUtils.InternalError(
+          import_devUtils.devUtils.formatMessage(
+            'Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.'
+          )
+        )
+      );
+    }
+  };
+  if (typeof handle === "function") {
+    return handle({
+      frame,
+      defaults: {
+        warn: printStrategyMessage.bind(null, "warn"),
+        /**
+         * @note The defaults only print the corresponding messages now.
+         * They do not affect the frame resolution (e.g. do not error the frame).
+         * That is only for backward compatibility reasons. In the future, these should
+         * be an alias to `applyStrategy.bind(null, 'error')` instead.
+         */
+        error: printStrategyMessage.bind(null, "error")
+      }
+    });
+  }
+  if (frame instanceof import_http_frame.HttpNetworkFrame && (0, import_isCommonAssetRequest.isCommonAssetRequest)(frame.data.request)) {
+    return;
+  }
+  return applyStrategy(handle);
+}
+//# sourceMappingURL=on-unhandled-frame.js.map

package/lib/core/experimental/on-unhandled-frame.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/experimental/on-unhandled-frame.ts"],"sourcesContent":["import { invariant } from 'outvariant'\nimport { isCommonAssetRequest } from '../isCommonAssetRequest'\nimport { devUtils, InternalError } from '../utils/internal/devUtils'\nimport { HttpNetworkFrame } from './frames/http-frame'\nimport { type AnyNetworkFrame } from './frames/network-frame'\n\nexport type UnhandledFrameHandle =\n  | UnhandledFrameStrategy\n  | UnhandledFrameCallback\n\nexport type UnhandledFrameStrategy = 'bypass' | 'warn' | 'error'\n\nexport type UnhandledFrameCallback = (args: {\n  frame: AnyNetworkFrame\n  defaults: UnhandledFrameDefaults\n}) => Promise<void> | void\n\nexport type UnhandledFrameDefaults = {\n  warn: () => void\n  error: () => void\n}\n\nexport async function executeUnhandledFrameHandle(\n  frame: AnyNetworkFrame,\n  handle: UnhandledFrameHandle,\n): Promise<void> {\n  const printStrategyMessage = async (\n    strategy: UnhandledFrameStrategy,\n  ): Promise<void> => {\n    if (strategy === 'bypass') {\n      return\n    }\n\n    const message = await frame.getUnhandledMessage()\n\n    switch (strategy) {\n      case 'warn': {\n        return devUtils.warn('Warning: %s', message)\n      }\n\n      case 'error': {\n        return devUtils.error('Error: %s', message)\n      }\n    }\n  }\n\n  const applyStrategy = async (\n    strategy: UnhandledFrameStrategy,\n  ): Promise<void> => {\n    invariant.as(\n      InternalError,\n      strategy === 'bypass' || strategy === 'warn' || strategy === 'error',\n      /**\n       * @fixme Rename \"onUnhandledRequest\" to \"onUnhandledFrame\" in the error message\n       * with the next major release.\n       */\n      devUtils.formatMessage(\n        'Failed to react to an unhandled network frame: unknown strategy \"%s\". Please provide one of the supported strategies (\"bypass\", \"warn\", \"error\") or a custom callback function as the value of the \"onUnhandledRequest\" option.',\n        strategy,\n      ),\n    )\n\n    if (strategy === 'bypass') {\n      return\n    }\n\n    await printStrategyMessage(strategy)\n\n    if (strategy === 'error') {\n      return Promise.reject(\n        new InternalError(\n          devUtils.formatMessage(\n            'Cannot bypass a request when using the \"error\" strategy for the \"onUnhandledRequest\" option.',\n          ),\n        ),\n      )\n    }\n  }\n\n  if (typeof handle === 'function') {\n    return handle({\n      frame,\n      defaults: {\n        warn: printStrategyMessage.bind(null, 'warn'),\n        /**\n         * @note The defaults only print the corresponding messages now.\n         * They do not affect the frame resolution (e.g. do not error the frame).\n         * That is only for backward compatibility reasons. In the future, these should\n         * be an alias to `applyStrategy.bind(null, 'error')` instead.\n         */\n        error: printStrategyMessage.bind(null, 'error'),\n      },\n    })\n  }\n\n  /**\n   * Ignore unhandled common HTTP assets.\n   * @note Calling this here applies the common assets check\n   * only to the scenarios when `onUnhandledFrame` was set to a predefined strategy.\n   * When using a custom function, you need to check for common assets manually.\n   */\n  if (\n    frame instanceof HttpNetworkFrame &&\n    isCommonAssetRequest(frame.data.request)\n  ) {\n    return\n  }\n\n  return applyStrategy(handle)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAA0B;AAC1B,kCAAqC;AACrC,sBAAwC;AACxC,wBAAiC;AAmBjC,eAAsB,4BACpB,OACA,QACe;AACf,QAAM,uBAAuB,OAC3B,aACkB;AAClB,QAAI,aAAa,UAAU;AACzB;AAAA,IACF;AAEA,UAAM,UAAU,MAAM,MAAM,oBAAoB;AAEhD,YAAQ,UAAU;AAAA,MAChB,KAAK,QAAQ;AACX,eAAO,yBAAS,KAAK,eAAe,OAAO;AAAA,MAC7C;AAAA,MAEA,KAAK,SAAS;AACZ,eAAO,yBAAS,MAAM,aAAa,OAAO;AAAA,MAC5C;AAAA,IACF;AAAA,EACF;AAEA,QAAM,gBAAgB,OACpB,aACkB;AAClB,gCAAU;AAAA,MACR;AAAA,MACA,aAAa,YAAY,aAAa,UAAU,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA,MAK7D,yBAAS;AAAA,QACP;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,QAAI,aAAa,UAAU;AACzB;AAAA,IACF;AAEA,UAAM,qBAAqB,QAAQ;AAEnC,QAAI,aAAa,SAAS;AACxB,aAAO,QAAQ;AAAA,QACb,IAAI;AAAA,UACF,yBAAS;AAAA,YACP;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,MAAI,OAAO,WAAW,YAAY;AAChC,WAAO,OAAO;AAAA,MACZ;AAAA,MACA,UAAU;AAAA,QACR,MAAM,qBAAqB,KAAK,MAAM,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAO5C,OAAO,qBAAqB,KAAK,MAAM,OAAO;AAAA,MAChD;AAAA,IACF,CAAC;AAAA,EACH;AAQA,MACE,iBAAiB,0CACjB,kDAAqB,MAAM,KAAK,OAAO,GACvC;AACA;AAAA,EACF;AAEA,SAAO,cAAc,MAAM;AAC7B;","names":[]}

package/lib/core/experimental/on-unhandled-frame.mjs

@@ -0,0 +1,70 @@
+import { invariant } from "outvariant";
+import { isCommonAssetRequest } from '../isCommonAssetRequest.mjs';
+import { devUtils, InternalError } from '../utils/internal/devUtils.mjs';
+import { HttpNetworkFrame } from './frames/http-frame.mjs';
+async function executeUnhandledFrameHandle(frame, handle) {
+  const printStrategyMessage = async (strategy) => {
+    if (strategy === "bypass") {
+      return;
+    }
+    const message = await frame.getUnhandledMessage();
+    switch (strategy) {
+      case "warn": {
+        return devUtils.warn("Warning: %s", message);
+      }
+      case "error": {
+        return devUtils.error("Error: %s", message);
+      }
+    }
+  };
+  const applyStrategy = async (strategy) => {
+    invariant.as(
+      InternalError,
+      strategy === "bypass" || strategy === "warn" || strategy === "error",
+      /**
+       * @fixme Rename "onUnhandledRequest" to "onUnhandledFrame" in the error message
+       * with the next major release.
+       */
+      devUtils.formatMessage(
+        'Failed to react to an unhandled network frame: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
+        strategy
+      )
+    );
+    if (strategy === "bypass") {
+      return;
+    }
+    await printStrategyMessage(strategy);
+    if (strategy === "error") {
+      return Promise.reject(
+        new InternalError(
+          devUtils.formatMessage(
+            'Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.'
+          )
+        )
+      );
+    }
+  };
+  if (typeof handle === "function") {
+    return handle({
+      frame,
+      defaults: {
+        warn: printStrategyMessage.bind(null, "warn"),
+        /**
+         * @note The defaults only print the corresponding messages now.
+         * They do not affect the frame resolution (e.g. do not error the frame).
+         * That is only for backward compatibility reasons. In the future, these should
+         * be an alias to `applyStrategy.bind(null, 'error')` instead.
+         */
+        error: printStrategyMessage.bind(null, "error")
+      }
+    });
+  }
+  if (frame instanceof HttpNetworkFrame && isCommonAssetRequest(frame.data.request)) {
+    return;
+  }
+  return applyStrategy(handle);
+}
+export {
+  executeUnhandledFrameHandle
+};
+//# sourceMappingURL=on-unhandled-frame.mjs.map

package/lib/core/experimental/on-unhandled-frame.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/experimental/on-unhandled-frame.ts"],"sourcesContent":["import { invariant } from 'outvariant'\nimport { isCommonAssetRequest } from '../isCommonAssetRequest'\nimport { devUtils, InternalError } from '../utils/internal/devUtils'\nimport { HttpNetworkFrame } from './frames/http-frame'\nimport { type AnyNetworkFrame } from './frames/network-frame'\n\nexport type UnhandledFrameHandle =\n  | UnhandledFrameStrategy\n  | UnhandledFrameCallback\n\nexport type UnhandledFrameStrategy = 'bypass' | 'warn' | 'error'\n\nexport type UnhandledFrameCallback = (args: {\n  frame: AnyNetworkFrame\n  defaults: UnhandledFrameDefaults\n}) => Promise<void> | void\n\nexport type UnhandledFrameDefaults = {\n  warn: () => void\n  error: () => void\n}\n\nexport async function executeUnhandledFrameHandle(\n  frame: AnyNetworkFrame,\n  handle: UnhandledFrameHandle,\n): Promise<void> {\n  const printStrategyMessage = async (\n    strategy: UnhandledFrameStrategy,\n  ): Promise<void> => {\n    if (strategy === 'bypass') {\n      return\n    }\n\n    const message = await frame.getUnhandledMessage()\n\n    switch (strategy) {\n      case 'warn': {\n        return devUtils.warn('Warning: %s', message)\n      }\n\n      case 'error': {\n        return devUtils.error('Error: %s', message)\n      }\n    }\n  }\n\n  const applyStrategy = async (\n    strategy: UnhandledFrameStrategy,\n  ): Promise<void> => {\n    invariant.as(\n      InternalError,\n      strategy === 'bypass' || strategy === 'warn' || strategy === 'error',\n      /**\n       * @fixme Rename \"onUnhandledRequest\" to \"onUnhandledFrame\" in the error message\n       * with the next major release.\n       */\n      devUtils.formatMessage(\n        'Failed to react to an unhandled network frame: unknown strategy \"%s\". Please provide one of the supported strategies (\"bypass\", \"warn\", \"error\") or a custom callback function as the value of the \"onUnhandledRequest\" option.',\n        strategy,\n      ),\n    )\n\n    if (strategy === 'bypass') {\n      return\n    }\n\n    await printStrategyMessage(strategy)\n\n    if (strategy === 'error') {\n      return Promise.reject(\n        new InternalError(\n          devUtils.formatMessage(\n            'Cannot bypass a request when using the \"error\" strategy for the \"onUnhandledRequest\" option.',\n          ),\n        ),\n      )\n    }\n  }\n\n  if (typeof handle === 'function') {\n    return handle({\n      frame,\n      defaults: {\n        warn: printStrategyMessage.bind(null, 'warn'),\n        /**\n         * @note The defaults only print the corresponding messages now.\n         * They do not affect the frame resolution (e.g. do not error the frame).\n         * That is only for backward compatibility reasons. In the future, these should\n         * be an alias to `applyStrategy.bind(null, 'error')` instead.\n         */\n        error: printStrategyMessage.bind(null, 'error'),\n      },\n    })\n  }\n\n  /**\n   * Ignore unhandled common HTTP assets.\n   * @note Calling this here applies the common assets check\n   * only to the scenarios when `onUnhandledFrame` was set to a predefined strategy.\n   * When using a custom function, you need to check for common assets manually.\n   */\n  if (\n    frame instanceof HttpNetworkFrame &&\n    isCommonAssetRequest(frame.data.request)\n  ) {\n    return\n  }\n\n  return applyStrategy(handle)\n}\n"],"mappings":"AAAA,SAAS,iBAAiB;AAC1B,SAAS,4BAA4B;AACrC,SAAS,UAAU,qBAAqB;AACxC,SAAS,wBAAwB;AAmBjC,eAAsB,4BACpB,OACA,QACe;AACf,QAAM,uBAAuB,OAC3B,aACkB;AAClB,QAAI,aAAa,UAAU;AACzB;AAAA,IACF;AAEA,UAAM,UAAU,MAAM,MAAM,oBAAoB;AAEhD,YAAQ,UAAU;AAAA,MAChB,KAAK,QAAQ;AACX,eAAO,SAAS,KAAK,eAAe,OAAO;AAAA,MAC7C;AAAA,MAEA,KAAK,SAAS;AACZ,eAAO,SAAS,MAAM,aAAa,OAAO;AAAA,MAC5C;AAAA,IACF;AAAA,EACF;AAEA,QAAM,gBAAgB,OACpB,aACkB;AAClB,cAAU;AAAA,MACR;AAAA,MACA,aAAa,YAAY,aAAa,UAAU,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA,MAK7D,SAAS;AAAA,QACP;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,QAAI,aAAa,UAAU;AACzB;AAAA,IACF;AAEA,UAAM,qBAAqB,QAAQ;AAEnC,QAAI,aAAa,SAAS;AACxB,aAAO,QAAQ;AAAA,QACb,IAAI;AAAA,UACF,SAAS;AAAA,YACP;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,MAAI,OAAO,WAAW,YAAY;AAChC,WAAO,OAAO;AAAA,MACZ;AAAA,MACA,UAAU;AAAA,QACR,MAAM,qBAAqB,KAAK,MAAM,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAO5C,OAAO,qBAAqB,KAAK,MAAM,OAAO;AAAA,MAChD;AAAA,IACF,CAAC;AAAA,EACH;AAQA,MACE,iBAAiB,oBACjB,qBAAqB,MAAM,KAAK,OAAO,GACvC;AACA;AAAA,EACF;AAEA,SAAO,cAAc,MAAM;AAC7B;","names":[]}

package/lib/core/experimental/request-utils.d.mts

@@ -0,0 +1,12 @@
+declare const REQUEST_INTENTION_HEADER_NAME = "x-msw-intention";
+declare enum RequestIntention {
+    passthrough = "passthrough"
+}
+declare function shouldBypassRequest(request: Request): boolean;
+declare function isPassthroughResponse(response: Response): boolean;
+/**
+ * Remove the internal passthrough instruction from the request's `Accept` header.
+ */
+declare function deleteRequestPassthroughHeader(request: Request): void;
+
+export { REQUEST_INTENTION_HEADER_NAME, RequestIntention, deleteRequestPassthroughHeader, isPassthroughResponse, shouldBypassRequest };

package/lib/core/experimental/request-utils.d.ts

@@ -0,0 +1,12 @@
+declare const REQUEST_INTENTION_HEADER_NAME = "x-msw-intention";
+declare enum RequestIntention {
+    passthrough = "passthrough"
+}
+declare function shouldBypassRequest(request: Request): boolean;
+declare function isPassthroughResponse(response: Response): boolean;
+/**
+ * Remove the internal passthrough instruction from the request's `Accept` header.
+ */
+declare function deleteRequestPassthroughHeader(request: Request): void;
+
+export { REQUEST_INTENTION_HEADER_NAME, RequestIntention, deleteRequestPassthroughHeader, isPassthroughResponse, shouldBypassRequest };

package/lib/core/experimental/request-utils.js

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var request_utils_exports = {};
+__export(request_utils_exports, {
+  REQUEST_INTENTION_HEADER_NAME: () => REQUEST_INTENTION_HEADER_NAME,
+  RequestIntention: () => RequestIntention,
+  deleteRequestPassthroughHeader: () => deleteRequestPassthroughHeader,
+  isPassthroughResponse: () => isPassthroughResponse,
+  shouldBypassRequest: () => shouldBypassRequest
+});
+module.exports = __toCommonJS(request_utils_exports);
+const REQUEST_INTENTION_HEADER_NAME = "x-msw-intention";
+var RequestIntention = /* @__PURE__ */ ((RequestIntention2) => {
+  RequestIntention2["passthrough"] = "passthrough";
+  return RequestIntention2;
+})(RequestIntention || {});
+function shouldBypassRequest(request) {
+  return !!request.headers.get("accept")?.includes("msw/passthrough");
+}
+function isPassthroughResponse(response) {
+  return response.status === 302 && response.headers.get(REQUEST_INTENTION_HEADER_NAME) === "passthrough" /* passthrough */;
+}
+function deleteRequestPassthroughHeader(request) {
+  const acceptHeader = request.headers.get("accept");
+  if (acceptHeader) {
+    const nextAcceptHeader = acceptHeader.replace(/(,\s+)?msw\/passthrough/, "");
+    if (nextAcceptHeader) {
+      request.headers.set("accept", nextAcceptHeader);
+    } else {
+      request.headers.delete("accept");
+    }
+  }
+}
+//# sourceMappingURL=request-utils.js.map

package/lib/core/experimental/request-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/experimental/request-utils.ts"],"sourcesContent":["export const REQUEST_INTENTION_HEADER_NAME = 'x-msw-intention'\n\nexport enum RequestIntention {\n  passthrough = 'passthrough',\n}\n\nexport function shouldBypassRequest(request: Request): boolean {\n  return !!request.headers.get('accept')?.includes('msw/passthrough')\n}\n\nexport function isPassthroughResponse(response: Response): boolean {\n  return (\n    response.status === 302 &&\n    response.headers.get(REQUEST_INTENTION_HEADER_NAME) ===\n      RequestIntention.passthrough\n  )\n}\n\n/**\n * Remove the internal passthrough instruction from the request's `Accept` header.\n */\nexport function deleteRequestPassthroughHeader(request: Request): void {\n  const acceptHeader = request.headers.get('accept')\n\n  /**\n   * @note Remove the internal bypass request header.\n   * In the browser, this is done by the worker script.\n   * In Node.js, it has to be done here.\n   */\n  if (acceptHeader) {\n    const nextAcceptHeader = acceptHeader.replace(/(,\\s+)?msw\\/passthrough/, '')\n\n    if (nextAcceptHeader) {\n      request.headers.set('accept', nextAcceptHeader)\n    } else {\n      request.headers.delete('accept')\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,gCAAgC;AAEtC,IAAK,mBAAL,kBAAKA,sBAAL;AACL,EAAAA,kBAAA,iBAAc;AADJ,SAAAA;AAAA,GAAA;AAIL,SAAS,oBAAoB,SAA2B;AAC7D,SAAO,CAAC,CAAC,QAAQ,QAAQ,IAAI,QAAQ,GAAG,SAAS,iBAAiB;AACpE;AAEO,SAAS,sBAAsB,UAA6B;AACjE,SACE,SAAS,WAAW,OACpB,SAAS,QAAQ,IAAI,6BAA6B,MAChD;AAEN;AAKO,SAAS,+BAA+B,SAAwB;AACrE,QAAM,eAAe,QAAQ,QAAQ,IAAI,QAAQ;AAOjD,MAAI,cAAc;AAChB,UAAM,mBAAmB,aAAa,QAAQ,2BAA2B,EAAE;AAE3E,QAAI,kBAAkB;AACpB,cAAQ,QAAQ,IAAI,UAAU,gBAAgB;AAAA,IAChD,OAAO;AACL,cAAQ,QAAQ,OAAO,QAAQ;AAAA,IACjC;AAAA,EACF;AACF;","names":["RequestIntention"]}

package/lib/core/experimental/request-utils.mjs

@@ -0,0 +1,30 @@
+const REQUEST_INTENTION_HEADER_NAME = "x-msw-intention";
+var RequestIntention = /* @__PURE__ */ ((RequestIntention2) => {
+  RequestIntention2["passthrough"] = "passthrough";
+  return RequestIntention2;
+})(RequestIntention || {});
+function shouldBypassRequest(request) {
+  return !!request.headers.get("accept")?.includes("msw/passthrough");
+}
+function isPassthroughResponse(response) {
+  return response.status === 302 && response.headers.get(REQUEST_INTENTION_HEADER_NAME) === "passthrough" /* passthrough */;
+}
+function deleteRequestPassthroughHeader(request) {
+  const acceptHeader = request.headers.get("accept");
+  if (acceptHeader) {
+    const nextAcceptHeader = acceptHeader.replace(/(,\s+)?msw\/passthrough/, "");
+    if (nextAcceptHeader) {
+      request.headers.set("accept", nextAcceptHeader);
+    } else {
+      request.headers.delete("accept");
+    }
+  }
+}
+export {
+  REQUEST_INTENTION_HEADER_NAME,
+  RequestIntention,
+  deleteRequestPassthroughHeader,
+  isPassthroughResponse,
+  shouldBypassRequest
+};
+//# sourceMappingURL=request-utils.mjs.map

package/lib/core/experimental/request-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/experimental/request-utils.ts"],"sourcesContent":["export const REQUEST_INTENTION_HEADER_NAME = 'x-msw-intention'\n\nexport enum RequestIntention {\n  passthrough = 'passthrough',\n}\n\nexport function shouldBypassRequest(request: Request): boolean {\n  return !!request.headers.get('accept')?.includes('msw/passthrough')\n}\n\nexport function isPassthroughResponse(response: Response): boolean {\n  return (\n    response.status === 302 &&\n    response.headers.get(REQUEST_INTENTION_HEADER_NAME) ===\n      RequestIntention.passthrough\n  )\n}\n\n/**\n * Remove the internal passthrough instruction from the request's `Accept` header.\n */\nexport function deleteRequestPassthroughHeader(request: Request): void {\n  const acceptHeader = request.headers.get('accept')\n\n  /**\n   * @note Remove the internal bypass request header.\n   * In the browser, this is done by the worker script.\n   * In Node.js, it has to be done here.\n   */\n  if (acceptHeader) {\n    const nextAcceptHeader = acceptHeader.replace(/(,\\s+)?msw\\/passthrough/, '')\n\n    if (nextAcceptHeader) {\n      request.headers.set('accept', nextAcceptHeader)\n    } else {\n      request.headers.delete('accept')\n    }\n  }\n}\n"],"mappings":"AAAO,MAAM,gCAAgC;AAEtC,IAAK,mBAAL,kBAAKA,sBAAL;AACL,EAAAA,kBAAA,iBAAc;AADJ,SAAAA;AAAA,GAAA;AAIL,SAAS,oBAAoB,SAA2B;AAC7D,SAAO,CAAC,CAAC,QAAQ,QAAQ,IAAI,QAAQ,GAAG,SAAS,iBAAiB;AACpE;AAEO,SAAS,sBAAsB,UAA6B;AACjE,SACE,SAAS,WAAW,OACpB,SAAS,QAAQ,IAAI,6BAA6B,MAChD;AAEN;AAKO,SAAS,+BAA+B,SAAwB;AACrE,QAAM,eAAe,QAAQ,QAAQ,IAAI,QAAQ;AAOjD,MAAI,cAAc;AAChB,UAAM,mBAAmB,aAAa,QAAQ,2BAA2B,EAAE;AAE3E,QAAI,kBAAkB;AACpB,cAAQ,QAAQ,IAAI,UAAU,gBAAgB;AAAA,IAChD,OAAO;AACL,cAAQ,QAAQ,OAAO,QAAQ;AAAA,IACjC;AAAA,EACF;AACF;","names":["RequestIntention"]}

package/lib/core/experimental/setup-api.d.mts

@@ -0,0 +1,33 @@
+import { DefaultEventMap, Emitter } from 'rettime';
+import { LifeCycleEventEmitter } from '../sharedOptions.mjs';
+import { HandlersController, AnyHandler } from './handlers-controller.mjs';
+import { Disposable } from '../utils/internal/Disposable.mjs';
+import '../utils/request/onUnhandledRequest.mjs';
+import '../HttpResponse-DlRR1D-f.mjs';
+import '@mswjs/interceptors';
+import '../utils/internal/isIterable.mjs';
+import '../typeUtils.mjs';
+import 'graphql';
+import '../utils/matching/matchRequestUrl.mjs';
+import '../handlers/WebSocketHandler.mjs';
+import 'strict-event-emitter';
+import '@mswjs/interceptors/WebSocket';
+
+/**
+ * Generic class for the mock API setup.
+ * Preserved only for backward compatibility.
+ * @deprecated
+ */
+declare abstract class SetupApi<EventMap extends DefaultEventMap> extends Disposable {
+    protected handlersController: HandlersController;
+    protected emitter: Emitter<EventMap>;
+    protected publicEmitter: Emitter<EventMap>;
+    readonly events: LifeCycleEventEmitter<EventMap>;
+    constructor(...initialHandlers: Array<AnyHandler>);
+    use(...runtimeHandlers: Array<AnyHandler>): void;
+    restoreHandlers(): void;
+    resetHandlers(...nextHandlers: Array<AnyHandler>): void;
+    listHandlers(): ReadonlyArray<AnyHandler>;
+}
+
+export { SetupApi };

package/lib/core/experimental/setup-api.d.ts

@@ -0,0 +1,33 @@
+import { DefaultEventMap, Emitter } from 'rettime';
+import { LifeCycleEventEmitter } from '../sharedOptions.js';
+import { HandlersController, AnyHandler } from './handlers-controller.js';
+import { Disposable } from '../utils/internal/Disposable.js';
+import '../utils/request/onUnhandledRequest.js';
+import '../HttpResponse-CksOMVAa.js';
+import '@mswjs/interceptors';
+import '../utils/internal/isIterable.js';
+import '../typeUtils.js';
+import 'graphql';
+import '../utils/matching/matchRequestUrl.js';
+import '../handlers/WebSocketHandler.js';
+import 'strict-event-emitter';
+import '@mswjs/interceptors/WebSocket';
+
+/**
+ * Generic class for the mock API setup.
+ * Preserved only for backward compatibility.
+ * @deprecated
+ */
+declare abstract class SetupApi<EventMap extends DefaultEventMap> extends Disposable {
+    protected handlersController: HandlersController;
+    protected emitter: Emitter<EventMap>;
+    protected publicEmitter: Emitter<EventMap>;
+    readonly events: LifeCycleEventEmitter<EventMap>;
+    constructor(...initialHandlers: Array<AnyHandler>);
+    use(...runtimeHandlers: Array<AnyHandler>): void;
+    restoreHandlers(): void;
+    resetHandlers(...nextHandlers: Array<AnyHandler>): void;
+    listHandlers(): ReadonlyArray<AnyHandler>;
+}
+
+export { SetupApi };