@depup/msw 2.12.13-depup.0

package/lib/core/isCommonAssetRequest.js

@@ -0,0 +1,42 @@
+"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 isCommonAssetRequest_exports = {};
+__export(isCommonAssetRequest_exports, {
+  isCommonAssetRequest: () => isCommonAssetRequest
+});
+module.exports = __toCommonJS(isCommonAssetRequest_exports);
+function isCommonAssetRequest(request) {
+  const url = new URL(request.url);
+  if (url.protocol === "file:") {
+    return true;
+  }
+  if (/(fonts\.googleapis\.com)/.test(url.hostname)) {
+    return true;
+  }
+  if (/node_modules/.test(url.pathname)) {
+    return true;
+  }
+  if (url.pathname.includes("@vite")) {
+    return true;
+  }
+  return /\.(s?css|less|m?jsx?|m?tsx?|html|ttf|otf|woff|woff2|eot|gif|jpe?g|png|avif|webp|svg|mp4|webm|ogg|mov|mp3|wav|ogg|flac|aac|pdf|txt|csv|json|xml|md|zip|tar|gz|rar|7z)$/i.test(
+    url.pathname
+  );
+}
+//# sourceMappingURL=isCommonAssetRequest.js.map

package/lib/core/isCommonAssetRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/isCommonAssetRequest.ts"],"sourcesContent":["/**\n * Determines if the given request is a static asset request.\n * Useful when deciding which unhandled requests to ignore.\n * @note Despite being ignored, you can still intercept and mock\n * static assets by creating request handlers for them.\n *\n * @example\n * import { isCommonAssetRequest } from 'msw'\n *\n * await worker.start({\n *   onUnhandledRequest(request, print) {\n *     if (!isCommonAssetRequest(request)) {\n *       print.warning()\n *     }\n *   }\n * })\n */\nexport function isCommonAssetRequest(request: Request): boolean {\n  const url = new URL(request.url)\n\n  // Ignore certain protocols.\n  if (url.protocol === 'file:') {\n    return true\n  }\n\n  // Ignore static assets hosts.\n  if (/(fonts\\.googleapis\\.com)/.test(url.hostname)) {\n    return true\n  }\n\n  // Ignore node modules served over HTTP.\n  if (/node_modules/.test(url.pathname)) {\n    return true\n  }\n\n  // Ignore internal Vite requests, like \"/@vite/client\".\n  if (url.pathname.includes('@vite')) {\n    return true\n  }\n\n  // Ignore common static assets.\n  return /\\.(s?css|less|m?jsx?|m?tsx?|html|ttf|otf|woff|woff2|eot|gif|jpe?g|png|avif|webp|svg|mp4|webm|ogg|mov|mp3|wav|ogg|flac|aac|pdf|txt|csv|json|xml|md|zip|tar|gz|rar|7z)$/i.test(\n    url.pathname,\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBO,SAAS,qBAAqB,SAA2B;AAC9D,QAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;AAG/B,MAAI,IAAI,aAAa,SAAS;AAC5B,WAAO;AAAA,EACT;AAGA,MAAI,2BAA2B,KAAK,IAAI,QAAQ,GAAG;AACjD,WAAO;AAAA,EACT;AAGA,MAAI,eAAe,KAAK,IAAI,QAAQ,GAAG;AACrC,WAAO;AAAA,EACT;AAGA,MAAI,IAAI,SAAS,SAAS,OAAO,GAAG;AAClC,WAAO;AAAA,EACT;AAGA,SAAO,yKAAyK;AAAA,IAC9K,IAAI;AAAA,EACN;AACF;","names":[]}

package/lib/core/isCommonAssetRequest.mjs

@@ -0,0 +1,22 @@
+function isCommonAssetRequest(request) {
+  const url = new URL(request.url);
+  if (url.protocol === "file:") {
+    return true;
+  }
+  if (/(fonts\.googleapis\.com)/.test(url.hostname)) {
+    return true;
+  }
+  if (/node_modules/.test(url.pathname)) {
+    return true;
+  }
+  if (url.pathname.includes("@vite")) {
+    return true;
+  }
+  return /\.(s?css|less|m?jsx?|m?tsx?|html|ttf|otf|woff|woff2|eot|gif|jpe?g|png|avif|webp|svg|mp4|webm|ogg|mov|mp3|wav|ogg|flac|aac|pdf|txt|csv|json|xml|md|zip|tar|gz|rar|7z)$/i.test(
+    url.pathname
+  );
+}
+export {
+  isCommonAssetRequest
+};
+//# sourceMappingURL=isCommonAssetRequest.mjs.map

package/lib/core/isCommonAssetRequest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/isCommonAssetRequest.ts"],"sourcesContent":["/**\n * Determines if the given request is a static asset request.\n * Useful when deciding which unhandled requests to ignore.\n * @note Despite being ignored, you can still intercept and mock\n * static assets by creating request handlers for them.\n *\n * @example\n * import { isCommonAssetRequest } from 'msw'\n *\n * await worker.start({\n *   onUnhandledRequest(request, print) {\n *     if (!isCommonAssetRequest(request)) {\n *       print.warning()\n *     }\n *   }\n * })\n */\nexport function isCommonAssetRequest(request: Request): boolean {\n  const url = new URL(request.url)\n\n  // Ignore certain protocols.\n  if (url.protocol === 'file:') {\n    return true\n  }\n\n  // Ignore static assets hosts.\n  if (/(fonts\\.googleapis\\.com)/.test(url.hostname)) {\n    return true\n  }\n\n  // Ignore node modules served over HTTP.\n  if (/node_modules/.test(url.pathname)) {\n    return true\n  }\n\n  // Ignore internal Vite requests, like \"/@vite/client\".\n  if (url.pathname.includes('@vite')) {\n    return true\n  }\n\n  // Ignore common static assets.\n  return /\\.(s?css|less|m?jsx?|m?tsx?|html|ttf|otf|woff|woff2|eot|gif|jpe?g|png|avif|webp|svg|mp4|webm|ogg|mov|mp3|wav|ogg|flac|aac|pdf|txt|csv|json|xml|md|zip|tar|gz|rar|7z)$/i.test(\n    url.pathname,\n  )\n}\n"],"mappings":"AAiBO,SAAS,qBAAqB,SAA2B;AAC9D,QAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;AAG/B,MAAI,IAAI,aAAa,SAAS;AAC5B,WAAO;AAAA,EACT;AAGA,MAAI,2BAA2B,KAAK,IAAI,QAAQ,GAAG;AACjD,WAAO;AAAA,EACT;AAGA,MAAI,eAAe,KAAK,IAAI,QAAQ,GAAG;AACrC,WAAO;AAAA,EACT;AAGA,MAAI,IAAI,SAAS,SAAS,OAAO,GAAG;AAClC,WAAO;AAAA,EACT;AAGA,SAAO,yKAAyK;AAAA,IAC9K,IAAI;AAAA,EACN;AACF;","names":[]}

package/lib/core/passthrough.d.mts

@@ -0,0 +1,24 @@
+import { H as HttpResponse } from './HttpResponse-Be4eT3x6.mjs';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.mjs';
+import './typeUtils.mjs';
+import 'graphql';
+import './utils/matching/matchRequestUrl.mjs';
+
+/**
+ * Performs the intercepted request as-is.
+ *
+ * This stops request handler lookup so no other handlers
+ * can affect this request past this point.
+ * Unlike `bypass()`, this will not trigger an additional request.
+ *
+ * @example
+ * http.get('/resource', () => {
+ *   return passthrough()
+ * })
+ *
+ * @see {@link https://mswjs.io/docs/api/passthrough `passthrough()` API reference}
+ */
+declare function passthrough(): HttpResponse<any>;
+
+export { passthrough };

package/lib/core/passthrough.d.ts

@@ -0,0 +1,24 @@
+import { H as HttpResponse } from './HttpResponse-Dj6ibgFJ.js';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.js';
+import './typeUtils.js';
+import 'graphql';
+import './utils/matching/matchRequestUrl.js';
+
+/**
+ * Performs the intercepted request as-is.
+ *
+ * This stops request handler lookup so no other handlers
+ * can affect this request past this point.
+ * Unlike `bypass()`, this will not trigger an additional request.
+ *
+ * @example
+ * http.get('/resource', () => {
+ *   return passthrough()
+ * })
+ *
+ * @see {@link https://mswjs.io/docs/api/passthrough `passthrough()` API reference}
+ */
+declare function passthrough(): HttpResponse<any>;
+
+export { passthrough };

package/lib/core/passthrough.js

@@ -0,0 +1,33 @@
+"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 passthrough_exports = {};
+__export(passthrough_exports, {
+  passthrough: () => passthrough
+});
+module.exports = __toCommonJS(passthrough_exports);
+function passthrough() {
+  return new Response(null, {
+    status: 302,
+    statusText: "Passthrough",
+    headers: {
+      "x-msw-intention": "passthrough"
+    }
+  });
+}
+//# sourceMappingURL=passthrough.js.map

package/lib/core/passthrough.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/passthrough.ts"],"sourcesContent":["import type { HttpResponse } from './HttpResponse'\n\n/**\n * Performs the intercepted request as-is.\n *\n * This stops request handler lookup so no other handlers\n * can affect this request past this point.\n * Unlike `bypass()`, this will not trigger an additional request.\n *\n * @example\n * http.get('/resource', () => {\n *   return passthrough()\n * })\n *\n * @see {@link https://mswjs.io/docs/api/passthrough `passthrough()` API reference}\n */\nexport function passthrough(): HttpResponse<any> {\n  return new Response(null, {\n    status: 302,\n    statusText: 'Passthrough',\n    headers: {\n      'x-msw-intention': 'passthrough',\n    },\n  }) as HttpResponse<any>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,SAAS,cAAiC;AAC/C,SAAO,IAAI,SAAS,MAAM;AAAA,IACxB,QAAQ;AAAA,IACR,YAAY;AAAA,IACZ,SAAS;AAAA,MACP,mBAAmB;AAAA,IACrB;AAAA,EACF,CAAC;AACH;","names":[]}

package/lib/core/passthrough.mjs

@@ -0,0 +1,13 @@
+function passthrough() {
+  return new Response(null, {
+    status: 302,
+    statusText: "Passthrough",
+    headers: {
+      "x-msw-intention": "passthrough"
+    }
+  });
+}
+export {
+  passthrough
+};
+//# sourceMappingURL=passthrough.mjs.map

package/lib/core/passthrough.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/passthrough.ts"],"sourcesContent":["import type { HttpResponse } from './HttpResponse'\n\n/**\n * Performs the intercepted request as-is.\n *\n * This stops request handler lookup so no other handlers\n * can affect this request past this point.\n * Unlike `bypass()`, this will not trigger an additional request.\n *\n * @example\n * http.get('/resource', () => {\n *   return passthrough()\n * })\n *\n * @see {@link https://mswjs.io/docs/api/passthrough `passthrough()` API reference}\n */\nexport function passthrough(): HttpResponse<any> {\n  return new Response(null, {\n    status: 302,\n    statusText: 'Passthrough',\n    headers: {\n      'x-msw-intention': 'passthrough',\n    },\n  }) as HttpResponse<any>\n}\n"],"mappings":"AAgBO,SAAS,cAAiC;AAC/C,SAAO,IAAI,SAAS,MAAM;AAAA,IACxB,QAAQ;AAAA,IACR,YAAY;AAAA,IACZ,SAAS;AAAA,MACP,mBAAmB;AAAA,IACrB;AAAA,EACF,CAAC;AACH;","names":[]}

package/lib/core/sharedOptions.d.mts

@@ -0,0 +1,64 @@
+import { Emitter } from 'strict-event-emitter';
+import { UnhandledRequestStrategy } from './utils/request/onUnhandledRequest.mjs';
+
+interface SharedOptions {
+    /**
+     * Specifies how to react to a request that has no corresponding
+     * request handler. Warns on unhandled requests by default.
+     *
+     * @example worker.start({ onUnhandledRequest: 'bypass' })
+     * @example worker.start({ onUnhandledRequest: 'warn' })
+     * @example server.listen({ onUnhandledRequest: 'error' })
+     */
+    onUnhandledRequest?: UnhandledRequestStrategy;
+}
+type LifeCycleEventsMap = {
+    'request:start': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:match': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:unhandled': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:end': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'response:mocked': [
+        args: {
+            response: Response;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'response:bypass': [
+        args: {
+            response: Response;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    unhandledException: [
+        args: {
+            error: Error;
+            request: Request;
+            requestId: string;
+        }
+    ];
+};
+type LifeCycleEventEmitter<EventsMap extends Record<string | symbol, any>> = Pick<Emitter<EventsMap>, 'on' | 'removeListener' | 'removeAllListeners'>;
+
+export type { LifeCycleEventEmitter, LifeCycleEventsMap, SharedOptions };

package/lib/core/sharedOptions.d.ts

@@ -0,0 +1,64 @@
+import { Emitter } from 'strict-event-emitter';
+import { UnhandledRequestStrategy } from './utils/request/onUnhandledRequest.js';
+
+interface SharedOptions {
+    /**
+     * Specifies how to react to a request that has no corresponding
+     * request handler. Warns on unhandled requests by default.
+     *
+     * @example worker.start({ onUnhandledRequest: 'bypass' })
+     * @example worker.start({ onUnhandledRequest: 'warn' })
+     * @example server.listen({ onUnhandledRequest: 'error' })
+     */
+    onUnhandledRequest?: UnhandledRequestStrategy;
+}
+type LifeCycleEventsMap = {
+    'request:start': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:match': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:unhandled': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:end': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'response:mocked': [
+        args: {
+            response: Response;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'response:bypass': [
+        args: {
+            response: Response;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    unhandledException: [
+        args: {
+            error: Error;
+            request: Request;
+            requestId: string;
+        }
+    ];
+};
+type LifeCycleEventEmitter<EventsMap extends Record<string | symbol, any>> = Pick<Emitter<EventsMap>, 'on' | 'removeListener' | 'removeAllListeners'>;
+
+export type { LifeCycleEventEmitter, LifeCycleEventsMap, SharedOptions };

package/lib/core/sharedOptions.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 sharedOptions_exports = {};
+module.exports = __toCommonJS(sharedOptions_exports);
+//# sourceMappingURL=sharedOptions.js.map

package/lib/core/sharedOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/sharedOptions.ts"],"sourcesContent":["import type { Emitter } from 'strict-event-emitter'\nimport type { UnhandledRequestStrategy } from './utils/request/onUnhandledRequest'\n\nexport interface SharedOptions {\n  /**\n   * Specifies how to react to a request that has no corresponding\n   * request handler. Warns on unhandled requests by default.\n   *\n   * @example worker.start({ onUnhandledRequest: 'bypass' })\n   * @example worker.start({ onUnhandledRequest: 'warn' })\n   * @example server.listen({ onUnhandledRequest: 'error' })\n   */\n  onUnhandledRequest?: UnhandledRequestStrategy\n}\n\nexport type LifeCycleEventsMap = {\n  'request:start': [\n    args: {\n      request: Request\n      requestId: string\n    },\n  ]\n  'request:match': [\n    args: {\n      request: Request\n      requestId: string\n    },\n  ]\n  'request:unhandled': [\n    args: {\n      request: Request\n      requestId: string\n    },\n  ]\n  'request:end': [\n    args: {\n      request: Request\n      requestId: string\n    },\n  ]\n  'response:mocked': [\n    args: {\n      response: Response\n      request: Request\n      requestId: string\n    },\n  ]\n  'response:bypass': [\n    args: {\n      response: Response\n      request: Request\n      requestId: string\n    },\n  ]\n  unhandledException: [\n    args: {\n      error: Error\n      request: Request\n      requestId: string\n    },\n  ]\n}\n\nexport type LifeCycleEventEmitter<\n  EventsMap extends Record<string | symbol, any>,\n> = Pick<Emitter<EventsMap>, 'on' | 'removeListener' | 'removeAllListeners'>\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/lib/core/sharedOptions.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=sharedOptions.mjs.map

package/lib/core/sharedOptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/lib/core/sse.d.mts

@@ -0,0 +1,116 @@
+import { Emitter } from 'strict-event-emitter';
+import { a as ResponseResolver } from './HttpResponse-Be4eT3x6.mjs';
+import { HttpRequestResolverExtras, HttpHandler } from './handlers/HttpHandler.mjs';
+import { PathParams, Path } from './utils/matching/matchRequestUrl.mjs';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.mjs';
+import './typeUtils.mjs';
+import 'graphql';
+
+type EventMapConstraint = {
+    message?: unknown;
+    [key: string]: unknown;
+    [key: symbol | number]: never;
+};
+type ServerSentEventResolverExtras<EventMap extends EventMapConstraint, Params extends PathParams> = HttpRequestResolverExtras<Params> & {
+    client: ServerSentEventClient<EventMap>;
+    server: ServerSentEventServer;
+};
+type ServerSentEventResolver<EventMap extends EventMapConstraint, Params extends PathParams> = ResponseResolver<ServerSentEventResolverExtras<EventMap, Params>, any, any>;
+type ServerSentEventRequestHandler = <EventMap extends EventMapConstraint = {
+    message: unknown;
+}, Params extends PathParams<keyof Params> = PathParams, RequestPath extends Path = Path>(path: RequestPath, resolver: ServerSentEventResolver<EventMap, Params>) => HttpHandler;
+type ServerSentEventMessage<EventMap extends EventMapConstraint = {
+    message: unknown;
+}> = ToEventDiscriminatedUnion<EventMap & {
+    message: unknown;
+}> | {
+    id?: never;
+    event?: never;
+    data?: never;
+    retry: number;
+};
+/**
+ * Intercept Server-Sent Events (SSE).
+ *
+ * @example
+ * sse('http://localhost:4321', ({ client }) => {
+ *   client.send({ data: 'hello world' })
+ * })
+ *
+ * @see {@link https://mswjs.io/docs/sse/ Mocking Server-Sent Events}
+ * @see {@link https://mswjs.io/docs/api/sse `sse()` API reference}
+ */
+declare const sse: ServerSentEventRequestHandler;
+type Values<T> = T[keyof T];
+type Identity<T> = {
+    [K in keyof T]: T[K];
+} & unknown;
+type ToEventDiscriminatedUnion<T> = Values<{
+    [K in keyof T]: Identity<(K extends 'message' ? {
+        id?: string;
+        event?: K;
+        data?: T[K];
+        retry?: never;
+    } : {
+        id?: string;
+        event: K;
+        data?: T[K];
+        retry?: never;
+    }) & (undefined extends T[K] ? unknown : {
+        data: unknown;
+    })>;
+}>;
+type ServerSentEventClientEventMap = {
+    message: [
+        payload: {
+            id?: string;
+            event: string;
+            data?: unknown;
+            frames: Array<string>;
+        }
+    ];
+    error: [];
+    close: [];
+};
+declare class ServerSentEventClient<EventMap extends EventMapConstraint = {
+    message: unknown;
+}> {
+    #private;
+    constructor(args: {
+        controller: ReadableStreamDefaultController;
+        emitter: Emitter<ServerSentEventClientEventMap>;
+    });
+    /**
+     * Sends the given payload to the intercepted `EventSource`.
+     */
+    send(payload: ServerSentEventMessage<EventMap>): void;
+    /**
+     * Dispatches the given event on the intercepted `EventSource`.
+     */
+    dispatchEvent(event: Event): void;
+    /**
+     * Errors the underlying `EventSource`, closing the connection with an error.
+     * This is equivalent to aborting the connection and will produce a `TypeError: Failed to fetch`
+     * error.
+     */
+    error(): void;
+    /**
+     * Closes the underlying `EventSource`, closing the connection.
+     */
+    close(): void;
+}
+declare class ServerSentEventServer {
+    #private;
+    constructor(args: {
+        request: Request;
+        client: ServerSentEventClient<any>;
+    });
+    /**
+     * Establishes the actual connection for this SSE request
+     * and returns the `EventSource` instance.
+     */
+    connect(): EventSource;
+}
+
+export { type ServerSentEventMessage, type ServerSentEventRequestHandler, type ServerSentEventResolver, type ServerSentEventResolverExtras, sse };

package/lib/core/sse.d.ts

@@ -0,0 +1,116 @@
+import { Emitter } from 'strict-event-emitter';
+import { a as ResponseResolver } from './HttpResponse-Dj6ibgFJ.js';
+import { HttpRequestResolverExtras, HttpHandler } from './handlers/HttpHandler.js';
+import { PathParams, Path } from './utils/matching/matchRequestUrl.js';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.js';
+import './typeUtils.js';
+import 'graphql';
+
+type EventMapConstraint = {
+    message?: unknown;
+    [key: string]: unknown;
+    [key: symbol | number]: never;
+};
+type ServerSentEventResolverExtras<EventMap extends EventMapConstraint, Params extends PathParams> = HttpRequestResolverExtras<Params> & {
+    client: ServerSentEventClient<EventMap>;
+    server: ServerSentEventServer;
+};
+type ServerSentEventResolver<EventMap extends EventMapConstraint, Params extends PathParams> = ResponseResolver<ServerSentEventResolverExtras<EventMap, Params>, any, any>;
+type ServerSentEventRequestHandler = <EventMap extends EventMapConstraint = {
+    message: unknown;
+}, Params extends PathParams<keyof Params> = PathParams, RequestPath extends Path = Path>(path: RequestPath, resolver: ServerSentEventResolver<EventMap, Params>) => HttpHandler;
+type ServerSentEventMessage<EventMap extends EventMapConstraint = {
+    message: unknown;
+}> = ToEventDiscriminatedUnion<EventMap & {
+    message: unknown;
+}> | {
+    id?: never;
+    event?: never;
+    data?: never;
+    retry: number;
+};
+/**
+ * Intercept Server-Sent Events (SSE).
+ *
+ * @example
+ * sse('http://localhost:4321', ({ client }) => {
+ *   client.send({ data: 'hello world' })
+ * })
+ *
+ * @see {@link https://mswjs.io/docs/sse/ Mocking Server-Sent Events}
+ * @see {@link https://mswjs.io/docs/api/sse `sse()` API reference}
+ */
+declare const sse: ServerSentEventRequestHandler;
+type Values<T> = T[keyof T];
+type Identity<T> = {
+    [K in keyof T]: T[K];
+} & unknown;
+type ToEventDiscriminatedUnion<T> = Values<{
+    [K in keyof T]: Identity<(K extends 'message' ? {
+        id?: string;
+        event?: K;
+        data?: T[K];
+        retry?: never;
+    } : {
+        id?: string;
+        event: K;
+        data?: T[K];
+        retry?: never;
+    }) & (undefined extends T[K] ? unknown : {
+        data: unknown;
+    })>;
+}>;
+type ServerSentEventClientEventMap = {
+    message: [
+        payload: {
+            id?: string;
+            event: string;
+            data?: unknown;
+            frames: Array<string>;
+        }
+    ];
+    error: [];
+    close: [];
+};
+declare class ServerSentEventClient<EventMap extends EventMapConstraint = {
+    message: unknown;
+}> {
+    #private;
+    constructor(args: {
+        controller: ReadableStreamDefaultController;
+        emitter: Emitter<ServerSentEventClientEventMap>;
+    });
+    /**
+     * Sends the given payload to the intercepted `EventSource`.
+     */
+    send(payload: ServerSentEventMessage<EventMap>): void;
+    /**
+     * Dispatches the given event on the intercepted `EventSource`.
+     */
+    dispatchEvent(event: Event): void;
+    /**
+     * Errors the underlying `EventSource`, closing the connection with an error.
+     * This is equivalent to aborting the connection and will produce a `TypeError: Failed to fetch`
+     * error.
+     */
+    error(): void;
+    /**
+     * Closes the underlying `EventSource`, closing the connection.
+     */
+    close(): void;
+}
+declare class ServerSentEventServer {
+    #private;
+    constructor(args: {
+        request: Request;
+        client: ServerSentEventClient<any>;
+    });
+    /**
+     * Establishes the actual connection for this SSE request
+     * and returns the `EventSource` instance.
+     */
+    connect(): EventSource;
+}
+
+export { type ServerSentEventMessage, type ServerSentEventRequestHandler, type ServerSentEventResolver, type ServerSentEventResolverExtras, sse };