msw
Version:
1,585 lines (1,544 loc) • 101 kB
JavaScript
"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);
// src/browser/index.ts
var index_exports = {};
__export(index_exports, {
SetupWorkerApi: () => SetupWorkerApi,
setupWorker: () => setupWorker
});
module.exports = __toCommonJS(index_exports);
// node_modules/.pnpm/outvariant@1.4.3/node_modules/outvariant/lib/index.mjs
var POSITIONALS_EXP = /(%?)(%([sdijo]))/g;
function serializePositional(positional, flag) {
switch (flag) {
case "s":
return positional;
case "d":
case "i":
return Number(positional);
case "j":
return JSON.stringify(positional);
case "o": {
if (typeof positional === "string") {
return positional;
}
const json = JSON.stringify(positional);
if (json === "{}" || json === "[]" || /^\[object .+?\]$/.test(json)) {
return positional;
}
return json;
}
}
}
function format(message, ...positionals) {
if (positionals.length === 0) {
return message;
}
let positionalIndex = 0;
let formattedMessage = message.replace(
POSITIONALS_EXP,
(match, isEscaped, _, flag) => {
const positional = positionals[positionalIndex];
const value = serializePositional(positional, flag);
if (!isEscaped) {
positionalIndex++;
return value;
}
return match;
}
);
if (positionalIndex < positionals.length) {
formattedMessage += ` ${positionals.slice(positionalIndex).join(" ")}`;
}
formattedMessage = formattedMessage.replace(/%{2,2}/g, "%");
return formattedMessage;
}
var STACK_FRAMES_TO_IGNORE = 2;
function cleanErrorStack(error2) {
if (!error2.stack) {
return;
}
const nextStack = error2.stack.split("\n");
nextStack.splice(1, STACK_FRAMES_TO_IGNORE);
error2.stack = nextStack.join("\n");
}
var InvariantError = class extends Error {
constructor(message, ...positionals) {
super(message);
this.message = message;
this.name = "Invariant Violation";
this.message = format(message, ...positionals);
cleanErrorStack(this);
}
};
var invariant = (predicate, message, ...positionals) => {
if (!predicate) {
throw new InvariantError(message, ...positionals);
}
};
invariant.as = (ErrorConstructor, predicate, message, ...positionals) => {
if (!predicate) {
const formatMessage = positionals.length === 0 ? message : format(message, ...positionals);
let error2;
try {
error2 = Reflect.construct(ErrorConstructor, [
formatMessage
]);
} catch (err) {
error2 = ErrorConstructor(formatMessage);
}
throw error2;
}
};
// node_modules/.pnpm/is-node-process@1.2.0/node_modules/is-node-process/lib/index.mjs
function isNodeProcess() {
if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
return true;
}
if (typeof process !== "undefined") {
const type = process.type;
if (type === "renderer" || type === "worker") {
return false;
}
return !!(process.versions && process.versions.node);
}
return false;
}
// src/browser/setupWorker/start/utils/prepareStartHandler.ts
var import_mergeRight = require("../core/utils/internal/mergeRight");
var DEFAULT_START_OPTIONS = {
serviceWorker: {
url: "/mockServiceWorker.js",
options: null
},
quiet: false,
waitUntilReady: true,
onUnhandledRequest: "warn",
findWorker(scriptURL, mockServiceWorkerUrl) {
return scriptURL === mockServiceWorkerUrl;
}
};
// src/browser/setupWorker/start/createStartHandler.ts
var import_devUtils6 = require("../core/utils/internal/devUtils");
// node_modules/.pnpm/@open-draft+until@2.1.0/node_modules/@open-draft/until/lib/index.mjs
var until = async (promise) => {
try {
const data = await promise().catch((error2) => {
throw error2;
});
return { error: null, data };
} catch (error2) {
return { error: error2, data: null };
}
};
// src/browser/setupWorker/start/utils/getWorkerInstance.ts
var import_devUtils = require("../core/utils/internal/devUtils");
// src/browser/utils/getAbsoluteWorkerUrl.ts
function getAbsoluteWorkerUrl(workerUrl) {
return new URL(workerUrl, location.href).href;
}
// src/browser/setupWorker/start/utils/getWorkerByRegistration.ts
function getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker) {
const allStates = [
registration.active,
registration.installing,
registration.waiting
];
const relevantStates = allStates.filter((state) => {
return state != null;
});
const worker = relevantStates.find((worker2) => {
return findWorker(worker2.scriptURL, absoluteWorkerUrl);
});
return worker || null;
}
// src/browser/setupWorker/start/utils/getWorkerInstance.ts
var getWorkerInstance = async (url, options = {}, findWorker) => {
const absoluteWorkerUrl = getAbsoluteWorkerUrl(url);
const mockRegistrations = await navigator.serviceWorker.getRegistrations().then(
(registrations) => registrations.filter(
(registration) => getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker)
)
);
if (!navigator.serviceWorker.controller && mockRegistrations.length > 0) {
location.reload();
}
const [existingRegistration] = mockRegistrations;
if (existingRegistration) {
existingRegistration.update();
return [
getWorkerByRegistration(
existingRegistration,
absoluteWorkerUrl,
findWorker
),
existingRegistration
];
}
const registrationResult = await until(
async () => {
const registration = await navigator.serviceWorker.register(url, options);
return [
// Compare existing worker registration by its worker URL,
// to prevent irrelevant workers to resolve here (such as Codesandbox worker).
getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker),
registration
];
}
);
if (registrationResult.error) {
const isWorkerMissing = registrationResult.error.message.includes("(404)");
if (isWorkerMissing) {
const scopeUrl = new URL(options?.scope || "/", location.href);
throw new Error(
import_devUtils.devUtils.formatMessage(`Failed to register a Service Worker for scope ('${scopeUrl.href}') with script ('${absoluteWorkerUrl}'): Service Worker script does not exist at the given path.
Did you forget to run "npx msw init <PUBLIC_DIR>"?
Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/init`)
);
}
throw new Error(
import_devUtils.devUtils.formatMessage(
"Failed to register the Service Worker:\n\n%s",
registrationResult.error.message
)
);
}
return registrationResult.data;
};
// node_modules/.pnpm/@open-draft+deferred-promise@2.2.0/node_modules/@open-draft/deferred-promise/build/index.mjs
function createDeferredExecutor() {
const executor = (resolve, reject) => {
executor.state = "pending";
executor.resolve = (data) => {
if (executor.state !== "pending") {
return;
}
executor.result = data;
const onFulfilled = (value) => {
executor.state = "fulfilled";
return value;
};
return resolve(
data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled)
);
};
executor.reject = (reason) => {
if (executor.state !== "pending") {
return;
}
queueMicrotask(() => {
executor.state = "rejected";
});
return reject(executor.rejectionReason = reason);
};
};
return executor;
}
var DeferredPromise = class extends Promise {
#executor;
resolve;
reject;
constructor(executor = null) {
const deferredExecutor = createDeferredExecutor();
super((originalResolve, originalReject) => {
deferredExecutor(originalResolve, originalReject);
executor?.(deferredExecutor.resolve, deferredExecutor.reject);
});
this.#executor = deferredExecutor;
this.resolve = this.#executor.resolve;
this.reject = this.#executor.reject;
}
get state() {
return this.#executor.state;
}
get rejectionReason() {
return this.#executor.rejectionReason;
}
then(onFulfilled, onRejected) {
return this.#decorate(super.then(onFulfilled, onRejected));
}
catch(onRejected) {
return this.#decorate(super.catch(onRejected));
}
finally(onfinally) {
return this.#decorate(super.finally(onfinally));
}
#decorate(promise) {
return Object.defineProperties(promise, {
resolve: { configurable: true, value: this.resolve },
reject: { configurable: true, value: this.reject }
});
}
};
// src/browser/setupWorker/start/utils/printStartMessage.ts
var import_devUtils2 = require("../core/utils/internal/devUtils");
function printStartMessage(args = {}) {
if (args.quiet) {
return;
}
const message = args.message || "Mocking enabled.";
console.groupCollapsed(
`%c${import_devUtils2.devUtils.formatMessage(message)}`,
"color:orangered;font-weight:bold;"
);
console.log(
"%cDocumentation: %chttps://mswjs.io/docs",
"font-weight:bold",
"font-weight:normal"
);
console.log("Found an issue? https://github.com/mswjs/msw/issues");
if (args.workerUrl) {
console.log("Worker script URL:", args.workerUrl);
}
if (args.workerScope) {
console.log("Worker scope:", args.workerScope);
}
if (args.client) {
console.log("Client ID: %s (%s)", args.client.id, args.client.frameType);
}
console.groupEnd();
}
// src/browser/setupWorker/start/utils/enableMocking.ts
function enableMocking(context, options) {
const mockingEnabledPromise = new DeferredPromise();
context.workerChannel.postMessage("MOCK_ACTIVATE");
context.workerChannel.once("MOCKING_ENABLED", async (event) => {
context.isMockingEnabled = true;
const worker = await context.workerPromise;
printStartMessage({
quiet: options.quiet,
workerScope: context.registration?.scope,
workerUrl: worker.scriptURL,
client: event.data.client
});
mockingEnabledPromise.resolve(true);
});
return mockingEnabledPromise;
}
// src/browser/utils/pruneGetRequestBody.ts
function pruneGetRequestBody(request) {
if (["HEAD", "GET"].includes(request.method)) {
return void 0;
}
return request.body;
}
// src/browser/utils/deserializeRequest.ts
function deserializeRequest(serializedRequest) {
return new Request(serializedRequest.url, {
...serializedRequest,
body: pruneGetRequestBody(serializedRequest)
});
}
// src/browser/setupWorker/start/createRequestListener.ts
var import_RequestHandler = require("../core/handlers/RequestHandler");
var import_handleRequest = require("../core/utils/handleRequest");
var import_devUtils3 = require("../core/utils/internal/devUtils");
var import_toResponseInit = require("../core/utils/toResponseInit");
var import_isHandlerKind = require("../core/utils/internal/isHandlerKind");
var createRequestListener = (context, options) => {
return async (event) => {
if (!context.isMockingEnabled && context.workerStoppedAt && event.data.interceptedAt > context.workerStoppedAt) {
event.postMessage("PASSTHROUGH");
return;
}
const requestId = event.data.id;
const request = deserializeRequest(event.data);
const requestCloneForLogs = request.clone();
const requestClone = request.clone();
import_RequestHandler.RequestHandler.cache.set(request, requestClone);
try {
await (0, import_handleRequest.handleRequest)(
request,
requestId,
context.getRequestHandlers().filter((0, import_isHandlerKind.isHandlerKind)("RequestHandler")),
options,
context.emitter,
{
onPassthroughResponse() {
event.postMessage("PASSTHROUGH");
},
async onMockedResponse(response, { handler, parsedResult }) {
const responseClone = response.clone();
const responseCloneForLogs = response.clone();
const responseInit = (0, import_toResponseInit.toResponseInit)(response);
if (context.supports.readableStreamTransfer) {
const responseStreamOrNull = response.body;
event.postMessage(
"MOCK_RESPONSE",
{
...responseInit,
body: responseStreamOrNull
},
responseStreamOrNull ? [responseStreamOrNull] : void 0
);
} else {
const responseBufferOrNull = response.body === null ? null : await responseClone.arrayBuffer();
event.postMessage("MOCK_RESPONSE", {
...responseInit,
body: responseBufferOrNull
});
}
if (!options.quiet) {
context.emitter.once("response:mocked", () => {
handler.log({
request: requestCloneForLogs,
response: responseCloneForLogs,
parsedResult
});
});
}
}
}
);
} catch (error2) {
if (error2 instanceof Error) {
import_devUtils3.devUtils.error(
`Uncaught exception in the request handler for "%s %s":
%s
This exception has been gracefully handled as a 500 response, however, it's strongly recommended to resolve this error, as it indicates a mistake in your code. If you wish to mock an error response, please see this guide: https://mswjs.io/docs/http/mocking-responses/error-responses`,
request.method,
request.url,
error2.stack ?? error2
);
event.postMessage("MOCK_RESPONSE", {
status: 500,
statusText: "Request Handler Error",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify({
name: error2.name,
message: error2.message,
stack: error2.stack
})
});
}
}
};
};
// src/browser/utils/checkWorkerIntegrity.ts
var import_devUtils4 = require("../core/utils/internal/devUtils");
function checkWorkerIntegrity(context) {
const integrityCheckPromise = new DeferredPromise();
context.workerChannel.postMessage("INTEGRITY_CHECK_REQUEST");
context.workerChannel.once("INTEGRITY_CHECK_RESPONSE", (event) => {
const { checksum, packageVersion } = event.data;
if (checksum !== "4db4a41e972cec1b64cc569c66952d82") {
import_devUtils4.devUtils.warn(
`The currently registered Service Worker has been generated by a different version of MSW (${packageVersion}) and may not be fully compatible with the installed version.
It's recommended you update your worker script by running this command:
\u2022 npx msw init <PUBLIC_DIR>
You can also automate this process and make the worker script update automatically upon the library installations. Read more: https://mswjs.io/docs/cli/init.`
);
}
integrityCheckPromise.resolve();
});
return integrityCheckPromise;
}
// node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-6HYIRFX2.mjs
var encoder = new TextEncoder();
function encodeBuffer(text) {
return encoder.encode(text);
}
function decodeBuffer(buffer, encoding) {
const decoder = new TextDecoder(encoding);
return decoder.decode(buffer);
}
function toArrayBuffer(array) {
return array.buffer.slice(
array.byteOffset,
array.byteOffset + array.byteLength
);
}
// node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-3RXCRGL2.mjs
var IS_PATCHED_MODULE = Symbol("isPatchedModule");
function canParseUrl(url) {
try {
new URL(url);
return true;
} catch (_error) {
return false;
}
}
function getValueBySymbol(symbolName, source) {
const ownSymbols = Object.getOwnPropertySymbols(source);
const symbol = ownSymbols.find((symbol2) => {
return symbol2.description === symbolName;
});
if (symbol) {
return Reflect.get(source, symbol);
}
return;
}
var _FetchResponse = class extends Response {
static isConfigurableStatusCode(status) {
return status >= 200 && status <= 599;
}
static isRedirectResponse(status) {
return _FetchResponse.STATUS_CODES_WITH_REDIRECT.includes(status);
}
/**
* Returns a boolean indicating whether the given response status
* code represents a response that can have a body.
*/
static isResponseWithBody(status) {
return !_FetchResponse.STATUS_CODES_WITHOUT_BODY.includes(status);
}
static setUrl(url, response) {
if (!url || url === "about:" || !canParseUrl(url)) {
return;
}
const state = getValueBySymbol("state", response);
if (state) {
state.urlList.push(new URL(url));
} else {
Object.defineProperty(response, "url", {
value: url,
enumerable: true,
configurable: true,
writable: false
});
}
}
/**
* Parses the given raw HTTP headers into a Fetch API `Headers` instance.
*/
static parseRawHeaders(rawHeaders) {
const headers = new Headers();
for (let line = 0; line < rawHeaders.length; line += 2) {
headers.append(rawHeaders[line], rawHeaders[line + 1]);
}
return headers;
}
constructor(body, init = {}) {
var _a;
const status = (_a = init.status) != null ? _a : 200;
const safeStatus = _FetchResponse.isConfigurableStatusCode(status) ? status : 200;
const finalBody = _FetchResponse.isResponseWithBody(status) ? body : null;
super(finalBody, {
status: safeStatus,
statusText: init.statusText,
headers: init.headers
});
if (status !== safeStatus) {
const state = getValueBySymbol("state", this);
if (state) {
state.status = status;
} else {
Object.defineProperty(this, "status", {
value: status,
enumerable: true,
configurable: true,
writable: false
});
}
}
_FetchResponse.setUrl(init.url, this);
}
};
var FetchResponse = _FetchResponse;
FetchResponse.STATUS_CODES_WITHOUT_BODY = [101, 103, 204, 205, 304];
FetchResponse.STATUS_CODES_WITH_REDIRECT = [301, 302, 303, 307, 308];
var kRawRequest = Symbol("kRawRequest");
function setRawRequest(request, rawRequest) {
Reflect.set(request, kRawRequest, rawRequest);
}
// node_modules/.pnpm/@open-draft+logger@0.3.0/node_modules/@open-draft/logger/lib/index.mjs
var __defProp2 = Object.defineProperty;
var __export2 = (target, all) => {
for (var name in all)
__defProp2(target, name, { get: all[name], enumerable: true });
};
var colors_exports = {};
__export2(colors_exports, {
blue: () => blue,
gray: () => gray,
green: () => green,
red: () => red,
yellow: () => yellow
});
function yellow(text) {
return `\x1B[33m${text}\x1B[0m`;
}
function blue(text) {
return `\x1B[34m${text}\x1B[0m`;
}
function gray(text) {
return `\x1B[90m${text}\x1B[0m`;
}
function red(text) {
return `\x1B[31m${text}\x1B[0m`;
}
function green(text) {
return `\x1B[32m${text}\x1B[0m`;
}
var IS_NODE = isNodeProcess();
var Logger = class {
constructor(name) {
this.name = name;
this.prefix = `[${this.name}]`;
const LOGGER_NAME = getVariable("DEBUG");
const LOGGER_LEVEL = getVariable("LOG_LEVEL");
const isLoggingEnabled = LOGGER_NAME === "1" || LOGGER_NAME === "true" || typeof LOGGER_NAME !== "undefined" && this.name.startsWith(LOGGER_NAME);
if (isLoggingEnabled) {
this.debug = isDefinedAndNotEquals(LOGGER_LEVEL, "debug") ? noop : this.debug;
this.info = isDefinedAndNotEquals(LOGGER_LEVEL, "info") ? noop : this.info;
this.success = isDefinedAndNotEquals(LOGGER_LEVEL, "success") ? noop : this.success;
this.warning = isDefinedAndNotEquals(LOGGER_LEVEL, "warning") ? noop : this.warning;
this.error = isDefinedAndNotEquals(LOGGER_LEVEL, "error") ? noop : this.error;
} else {
this.info = noop;
this.success = noop;
this.warning = noop;
this.error = noop;
this.only = noop;
}
}
prefix;
extend(domain) {
return new Logger(`${this.name}:${domain}`);
}
/**
* Print a debug message.
* @example
* logger.debug('no duplicates found, creating a document...')
*/
debug(message, ...positionals) {
this.logEntry({
level: "debug",
message: gray(message),
positionals,
prefix: this.prefix,
colors: {
prefix: "gray"
}
});
}
/**
* Print an info message.
* @example
* logger.info('start parsing...')
*/
info(message, ...positionals) {
this.logEntry({
level: "info",
message,
positionals,
prefix: this.prefix,
colors: {
prefix: "blue"
}
});
const performance2 = new PerformanceEntry();
return (message2, ...positionals2) => {
performance2.measure();
this.logEntry({
level: "info",
message: `${message2} ${gray(`${performance2.deltaTime}ms`)}`,
positionals: positionals2,
prefix: this.prefix,
colors: {
prefix: "blue"
}
});
};
}
/**
* Print a success message.
* @example
* logger.success('successfully created document')
*/
success(message, ...positionals) {
this.logEntry({
level: "info",
message,
positionals,
prefix: `\u2714 ${this.prefix}`,
colors: {
timestamp: "green",
prefix: "green"
}
});
}
/**
* Print a warning.
* @example
* logger.warning('found legacy document format')
*/
warning(message, ...positionals) {
this.logEntry({
level: "warning",
message,
positionals,
prefix: `\u26A0 ${this.prefix}`,
colors: {
timestamp: "yellow",
prefix: "yellow"
}
});
}
/**
* Print an error message.
* @example
* logger.error('something went wrong')
*/
error(message, ...positionals) {
this.logEntry({
level: "error",
message,
positionals,
prefix: `\u2716 ${this.prefix}`,
colors: {
timestamp: "red",
prefix: "red"
}
});
}
/**
* Execute the given callback only when the logging is enabled.
* This is skipped in its entirety and has no runtime cost otherwise.
* This executes regardless of the log level.
* @example
* logger.only(() => {
* logger.info('additional info')
* })
*/
only(callback) {
callback();
}
createEntry(level, message) {
return {
timestamp: /* @__PURE__ */ new Date(),
level,
message
};
}
logEntry(args) {
const {
level,
message,
prefix,
colors: customColors,
positionals = []
} = args;
const entry = this.createEntry(level, message);
const timestampColor = customColors?.timestamp || "gray";
const prefixColor = customColors?.prefix || "gray";
const colorize = {
timestamp: colors_exports[timestampColor],
prefix: colors_exports[prefixColor]
};
const write = this.getWriter(level);
write(
[colorize.timestamp(this.formatTimestamp(entry.timestamp))].concat(prefix != null ? colorize.prefix(prefix) : []).concat(serializeInput(message)).join(" "),
...positionals.map(serializeInput)
);
}
formatTimestamp(timestamp) {
return `${timestamp.toLocaleTimeString(
"en-GB"
)}:${timestamp.getMilliseconds()}`;
}
getWriter(level) {
switch (level) {
case "debug":
case "success":
case "info": {
return log;
}
case "warning": {
return warn;
}
case "error": {
return error;
}
}
}
};
var PerformanceEntry = class {
startTime;
endTime;
deltaTime;
constructor() {
this.startTime = performance.now();
}
measure() {
this.endTime = performance.now();
const deltaTime = this.endTime - this.startTime;
this.deltaTime = deltaTime.toFixed(2);
}
};
var noop = () => void 0;
function log(message, ...positionals) {
if (IS_NODE) {
process.stdout.write(format(message, ...positionals) + "\n");
return;
}
console.log(message, ...positionals);
}
function warn(message, ...positionals) {
if (IS_NODE) {
process.stderr.write(format(message, ...positionals) + "\n");
return;
}
console.warn(message, ...positionals);
}
function error(message, ...positionals) {
if (IS_NODE) {
process.stderr.write(format(message, ...positionals) + "\n");
return;
}
console.error(message, ...positionals);
}
function getVariable(variableName) {
if (IS_NODE) {
return process.env[variableName];
}
return globalThis[variableName]?.toString();
}
function isDefinedAndNotEquals(value, expected) {
return value !== void 0 && value !== expected;
}
function serializeInput(message) {
if (typeof message === "undefined") {
return "undefined";
}
if (message === null) {
return "null";
}
if (typeof message === "string") {
return message;
}
if (typeof message === "object") {
return JSON.stringify(message);
}
return message.toString();
}
// node_modules/.pnpm/strict-event-emitter@0.5.1/node_modules/strict-event-emitter/lib/index.mjs
var MemoryLeakError = class extends Error {
constructor(emitter, type, count) {
super(
`Possible EventEmitter memory leak detected. ${count} ${type.toString()} listeners added. Use emitter.setMaxListeners() to increase limit`
);
this.emitter = emitter;
this.type = type;
this.count = count;
this.name = "MaxListenersExceededWarning";
}
};
var _Emitter = class {
static listenerCount(emitter, eventName) {
return emitter.listenerCount(eventName);
}
constructor() {
this.events = /* @__PURE__ */ new Map();
this.maxListeners = _Emitter.defaultMaxListeners;
this.hasWarnedAboutPotentialMemoryLeak = false;
}
_emitInternalEvent(internalEventName, eventName, listener) {
this.emit(
internalEventName,
...[eventName, listener]
);
}
_getListeners(eventName) {
return Array.prototype.concat.apply([], this.events.get(eventName)) || [];
}
_removeListener(listeners, listener) {
const index = listeners.indexOf(listener);
if (index > -1) {
listeners.splice(index, 1);
}
return [];
}
_wrapOnceListener(eventName, listener) {
const onceListener = (...data) => {
this.removeListener(eventName, onceListener);
return listener.apply(this, data);
};
Object.defineProperty(onceListener, "name", { value: listener.name });
return onceListener;
}
setMaxListeners(maxListeners) {
this.maxListeners = maxListeners;
return this;
}
/**
* Returns the current max listener value for the `Emitter` which is
* either set by `emitter.setMaxListeners(n)` or defaults to
* `Emitter.defaultMaxListeners`.
*/
getMaxListeners() {
return this.maxListeners;
}
/**
* Returns an array listing the events for which the emitter has registered listeners.
* The values in the array will be strings or Symbols.
*/
eventNames() {
return Array.from(this.events.keys());
}
/**
* Synchronously calls each of the listeners registered for the event named `eventName`,
* in the order they were registered, passing the supplied arguments to each.
* Returns `true` if the event has listeners, `false` otherwise.
*
* @example
* const emitter = new Emitter<{ hello: [string] }>()
* emitter.emit('hello', 'John')
*/
emit(eventName, ...data) {
const listeners = this._getListeners(eventName);
listeners.forEach((listener) => {
listener.apply(this, data);
});
return listeners.length > 0;
}
addListener(eventName, listener) {
this._emitInternalEvent("newListener", eventName, listener);
const nextListeners = this._getListeners(eventName).concat(listener);
this.events.set(eventName, nextListeners);
if (this.maxListeners > 0 && this.listenerCount(eventName) > this.maxListeners && !this.hasWarnedAboutPotentialMemoryLeak) {
this.hasWarnedAboutPotentialMemoryLeak = true;
const memoryLeakWarning = new MemoryLeakError(
this,
eventName,
this.listenerCount(eventName)
);
console.warn(memoryLeakWarning);
}
return this;
}
on(eventName, listener) {
return this.addListener(eventName, listener);
}
once(eventName, listener) {
return this.addListener(
eventName,
this._wrapOnceListener(eventName, listener)
);
}
prependListener(eventName, listener) {
const listeners = this._getListeners(eventName);
if (listeners.length > 0) {
const nextListeners = [listener].concat(listeners);
this.events.set(eventName, nextListeners);
} else {
this.events.set(eventName, listeners.concat(listener));
}
return this;
}
prependOnceListener(eventName, listener) {
return this.prependListener(
eventName,
this._wrapOnceListener(eventName, listener)
);
}
removeListener(eventName, listener) {
const listeners = this._getListeners(eventName);
if (listeners.length > 0) {
this._removeListener(listeners, listener);
this.events.set(eventName, listeners);
this._emitInternalEvent("removeListener", eventName, listener);
}
return this;
}
/**
* Alias for `emitter.removeListener()`.
*
* @example
* emitter.off('hello', listener)
*/
off(eventName, listener) {
return this.removeListener(eventName, listener);
}
removeAllListeners(eventName) {
if (eventName) {
this.events.delete(eventName);
} else {
this.events.clear();
}
return this;
}
/**
* Returns a copy of the array of listeners for the event named `eventName`.
*/
listeners(eventName) {
return Array.from(this._getListeners(eventName));
}
/**
* Returns the number of listeners listening to the event named `eventName`.
*/
listenerCount(eventName) {
return this._getListeners(eventName).length;
}
rawListeners(eventName) {
return this.listeners(eventName);
}
};
var Emitter = _Emitter;
Emitter.defaultMaxListeners = 10;
// node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-QED3Q6Z2.mjs
var INTERNAL_REQUEST_ID_HEADER_NAME = "x-interceptors-internal-request-id";
function getGlobalSymbol(symbol) {
return (
// @ts-ignore https://github.com/Microsoft/TypeScript/issues/24587
globalThis[symbol] || void 0
);
}
function setGlobalSymbol(symbol, value) {
globalThis[symbol] = value;
}
function deleteGlobalSymbol(symbol) {
delete globalThis[symbol];
}
var Interceptor = class {
constructor(symbol) {
this.symbol = symbol;
this.readyState = "INACTIVE";
this.emitter = new Emitter();
this.subscriptions = [];
this.logger = new Logger(symbol.description);
this.emitter.setMaxListeners(0);
this.logger.info("constructing the interceptor...");
}
/**
* Determine if this interceptor can be applied
* in the current environment.
*/
checkEnvironment() {
return true;
}
/**
* Apply this interceptor to the current process.
* Returns an already running interceptor instance if it's present.
*/
apply() {
const logger = this.logger.extend("apply");
logger.info("applying the interceptor...");
if (this.readyState === "APPLIED") {
logger.info("intercepted already applied!");
return;
}
const shouldApply = this.checkEnvironment();
if (!shouldApply) {
logger.info("the interceptor cannot be applied in this environment!");
return;
}
this.readyState = "APPLYING";
const runningInstance = this.getInstance();
if (runningInstance) {
logger.info("found a running instance, reusing...");
this.on = (event, listener) => {
logger.info('proxying the "%s" listener', event);
runningInstance.emitter.addListener(event, listener);
this.subscriptions.push(() => {
runningInstance.emitter.removeListener(event, listener);
logger.info('removed proxied "%s" listener!', event);
});
return this;
};
this.readyState = "APPLIED";
return;
}
logger.info("no running instance found, setting up a new instance...");
this.setup();
this.setInstance();
this.readyState = "APPLIED";
}
/**
* Setup the module augments and stubs necessary for this interceptor.
* This method is not run if there's a running interceptor instance
* to prevent instantiating an interceptor multiple times.
*/
setup() {
}
/**
* Listen to the interceptor's public events.
*/
on(event, listener) {
const logger = this.logger.extend("on");
if (this.readyState === "DISPOSING" || this.readyState === "DISPOSED") {
logger.info("cannot listen to events, already disposed!");
return this;
}
logger.info('adding "%s" event listener:', event, listener);
this.emitter.on(event, listener);
return this;
}
once(event, listener) {
this.emitter.once(event, listener);
return this;
}
off(event, listener) {
this.emitter.off(event, listener);
return this;
}
removeAllListeners(event) {
this.emitter.removeAllListeners(event);
return this;
}
/**
* Disposes of any side-effects this interceptor has introduced.
*/
dispose() {
const logger = this.logger.extend("dispose");
if (this.readyState === "DISPOSED") {
logger.info("cannot dispose, already disposed!");
return;
}
logger.info("disposing the interceptor...");
this.readyState = "DISPOSING";
if (!this.getInstance()) {
logger.info("no interceptors running, skipping dispose...");
return;
}
this.clearInstance();
logger.info("global symbol deleted:", getGlobalSymbol(this.symbol));
if (this.subscriptions.length > 0) {
logger.info("disposing of %d subscriptions...", this.subscriptions.length);
for (const dispose of this.subscriptions) {
dispose();
}
this.subscriptions = [];
logger.info("disposed of all subscriptions!", this.subscriptions.length);
}
this.emitter.removeAllListeners();
logger.info("destroyed the listener!");
this.readyState = "DISPOSED";
}
getInstance() {
var _a;
const instance = getGlobalSymbol(this.symbol);
this.logger.info("retrieved global instance:", (_a = instance == null ? void 0 : instance.constructor) == null ? void 0 : _a.name);
return instance;
}
setInstance() {
setGlobalSymbol(this.symbol, this);
this.logger.info("set global instance!", this.symbol.description);
}
clearInstance() {
deleteGlobalSymbol(this.symbol);
this.logger.info("cleared global instance!", this.symbol.description);
}
};
function createRequestId() {
return Math.random().toString(16).slice(2);
}
// node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/index.mjs
var BatchInterceptor = class extends Interceptor {
constructor(options) {
BatchInterceptor.symbol = Symbol(options.name);
super(BatchInterceptor.symbol);
this.interceptors = options.interceptors;
}
setup() {
const logger = this.logger.extend("setup");
logger.info("applying all %d interceptors...", this.interceptors.length);
for (const interceptor of this.interceptors) {
logger.info('applying "%s" interceptor...', interceptor.constructor.name);
interceptor.apply();
logger.info("adding interceptor dispose subscription");
this.subscriptions.push(() => interceptor.dispose());
}
}
on(event, listener) {
for (const interceptor of this.interceptors) {
interceptor.on(event, listener);
}
return this;
}
once(event, listener) {
for (const interceptor of this.interceptors) {
interceptor.once(event, listener);
}
return this;
}
off(event, listener) {
for (const interceptor of this.interceptors) {
interceptor.off(event, listener);
}
return this;
}
removeAllListeners(event) {
for (const interceptors of this.interceptors) {
interceptors.removeAllListeners(event);
}
return this;
}
};
// src/browser/setupWorker/start/createResponseListener.ts
function createResponseListener(context) {
return (event) => {
const responseMessage = event.data;
const request = deserializeRequest(responseMessage.request);
if (responseMessage.response.type?.includes("opaque")) {
return;
}
const response = responseMessage.response.status === 0 ? Response.error() : new FetchResponse(
/**
* Responses may be streams here, but when we create a response object
* with null-body status codes, like 204, 205, 304 Response will
* throw when passed a non-null body, so ensure it's null here
* for those codes
*/
FetchResponse.isResponseWithBody(responseMessage.response.status) ? responseMessage.response.body : null,
{
...responseMessage,
/**
* Set response URL if it's not set already.
* @see https://github.com/mswjs/msw/issues/2030
* @see https://developer.mozilla.org/en-US/docs/Web/API/Response/url
*/
url: request.url
}
);
context.emitter.emit(
responseMessage.isMockedResponse ? "response:mocked" : "response:bypass",
{
requestId: responseMessage.request.id,
request,
response
}
);
};
}
// src/browser/setupWorker/start/utils/validateWorkerScope.ts
var import_devUtils5 = require("../core/utils/internal/devUtils");
function validateWorkerScope(registration, options) {
if (!options?.quiet && !location.href.startsWith(registration.scope)) {
import_devUtils5.devUtils.warn(
`Cannot intercept requests on this page because it's outside of the worker's scope ("${registration.scope}"). If you wish to mock API requests on this page, you must resolve this scope issue.
- (Recommended) Register the worker at the root level ("/") of your application.
- Set the "Service-Worker-Allowed" response header to allow out-of-scope workers.`
);
}
}
// src/browser/setupWorker/start/createStartHandler.ts
var createStartHandler = (context) => {
return function start(options, customOptions) {
const startWorkerInstance = async () => {
context.workerChannel.removeAllListeners();
context.workerChannel.on(
"REQUEST",
createRequestListener(context, options)
);
context.workerChannel.on("RESPONSE", createResponseListener(context));
const instance = await getWorkerInstance(
options.serviceWorker.url,
options.serviceWorker.options,
options.findWorker
);
const [worker, registration] = instance;
if (!worker) {
const missingWorkerMessage = customOptions?.findWorker ? import_devUtils6.devUtils.formatMessage(
`Failed to locate the Service Worker registration using a custom "findWorker" predicate.
Please ensure that the custom predicate properly locates the Service Worker registration at "%s".
More details: https://mswjs.io/docs/api/setup-worker/start#findworker
`,
options.serviceWorker.url
) : import_devUtils6.devUtils.formatMessage(
`Failed to locate the Service Worker registration.
This most likely means that the worker script URL "%s" cannot resolve against the actual public hostname (%s). This may happen if your application runs behind a proxy, or has a dynamic hostname.
Please consider using a custom "serviceWorker.url" option to point to the actual worker script location, or a custom "findWorker" option to resolve the Service Worker registration manually. More details: https://mswjs.io/docs/api/setup-worker/start`,
options.serviceWorker.url,
location.host
);
throw new Error(missingWorkerMessage);
}
context.workerPromise.resolve(worker);
context.registration = registration;
window.addEventListener("beforeunload", () => {
if (worker.state !== "redundant") {
context.workerChannel.postMessage("CLIENT_CLOSED");
}
window.clearInterval(context.keepAliveInterval);
window.postMessage({ type: "msw/worker:stop" });
});
await checkWorkerIntegrity(context).catch((error2) => {
import_devUtils6.devUtils.error(
"Error while checking the worker script integrity. Please report this on GitHub (https://github.com/mswjs/msw/issues) and include the original error below."
);
console.error(error2);
});
context.keepAliveInterval = window.setInterval(
() => context.workerChannel.postMessage("KEEPALIVE_REQUEST"),
5e3
);
validateWorkerScope(registration, context.startOptions);
return registration;
};
const workerRegistration = startWorkerInstance().then(
async (registration) => {
const pendingInstance = registration.installing || registration.waiting;
if (pendingInstance) {
const activationPromise = new DeferredPromise();
pendingInstance.addEventListener("statechange", () => {
if (pendingInstance.state === "activated") {
activationPromise.resolve();
}
});
await activationPromise;
}
await enableMocking(context, options).catch((error2) => {
import_devUtils6.devUtils.error(
"Failed to enable mocking. Please report this on GitHub (https://github.com/mswjs/msw/issues) and include the original error below."
);
throw error2;
});
return registration;
}
);
return workerRegistration;
};
};
// src/browser/setupWorker/setupWorker.ts
var import_devUtils8 = require("../core/utils/internal/devUtils");
var import_SetupApi = require("../core/SetupApi");
var import_mergeRight2 = require("../core/utils/internal/mergeRight");
// src/browser/utils/supportsReadableStreamTransfer.ts
function supportsReadableStreamTransfer() {
try {
const stream = new ReadableStream({
start: (controller) => controller.close()
});
const message = new MessageChannel();
message.port1.postMessage(stream, [stream]);
return true;
} catch {
return false;
}
}
// src/browser/setupWorker/setupWorker.ts
var import_webSocketInterceptor = require("../core/ws/webSocketInterceptor");
var import_handleWebSocketEvent = require("../core/ws/handleWebSocketEvent");
var import_attachWebSocketLogger = require("../core/ws/utils/attachWebSocketLogger");
// node_modules/.pnpm/rettime@0.7.0/node_modules/rettime/build/index.js
var kDefaultPrevented = Symbol("kDefaultPrevented");
var kPropagationStopped = Symbol("kPropagationStopped");
var kImmediatePropagationStopped = Symbol("kImmediatePropagationStopped");
var TypedEvent = class extends MessageEvent {
/**
* @note Keep a placeholder property with the return type
* because the type must be set somewhere in order to be
* correctly associated and inferred from the event.
*/
#returnType;
[kDefaultPrevented];
[kPropagationStopped];
[kImmediatePropagationStopped];
constructor(...args) {
super(args[0], args[1]);
this[kDefaultPrevented] = false;
}
get defaultPrevented() {
return this[kDefaultPrevented];
}
preventDefault() {
super.preventDefault();
this[kDefaultPrevented] = true;
}
stopImmediatePropagation() {
super.stopImmediatePropagation();
this[kImmediatePropagationStopped] = true;
}
};
var kListenerOptions = Symbol("kListenerOptions");
var Emitter2 = class {
#listeners;
constructor() {
this.#listeners = {};
}
/**
* Adds a listener for the given event type.
*
* @returns {AbortController} An `AbortController` that can be used to remove the listener.
*/
on(type, listener, options) {
return this.#addListener(type, listener, options);
}
/**
* Adds a one-time listener for the given event type.
*
* @returns {AbortController} An `AbortController` that can be used to remove the listener.
*/
once(type, listener, options) {
return this.on(type, listener, { ...options || {}, once: true });
}
/**
* Prepends a listener for the given event type.
*
* @returns {AbortController} An `AbortController` that can be used to remove the listener.
*/
earlyOn(type, listener, options) {
return this.#addListener(type, listener, options, "prepend");
}
/**
* Prepends a one-time listener for the given event type.
*/
earlyOnce(type, listener, options) {
return this.earlyOn(type, listener, { ...options || {}, once: true });
}
/**
* Emits the given typed event.
*
* @returns {boolean} Returns `true` if the event had any listeners, `false` otherwise.
*/
emit(event) {
if (this.listenerCount(event.type) === 0) {
return false;
}
const proxiedEvent = this.#proxyEvent(event);
for (const listener of this.#listeners[event.type]) {
if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
return false;
}
if (proxiedEvent.event[kImmediatePropagationStopped]) {
break;
}
this.#callListener(proxiedEvent.event, listener);
}
proxiedEvent.revoke();
return true;
}
/**
* Emits the given typed event and returns a promise that resolves
* when all the listeners for that event have settled.
*
* @returns {Promise<Array<Emitter.ListenerReturnType>>} A promise that resolves
* with the return values of all listeners.
*/
async emitAsPromise(event) {
if (this.listenerCount(event.type) === 0) {
return [];
}
const pendingListeners = [];
const proxiedEvent = this.#proxyEvent(event);
for (const listener of this.#listeners[event.type]) {
if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
return [];
}
if (proxiedEvent.event[kImmediatePropagationStopped]) {
break;
}
pendingListeners.push(
// Awaiting individual listeners guarantees their call order.
await Promise.resolve(this.#callListener(proxiedEvent.event, listener))
);
}
proxiedEvent.revoke();
return Promise.allSettled(pendingListeners).then((results) => {
return results.map(
(result) => result.status === "fulfilled" ? result.value : result.reason
);
});
}
/**
* Emits the given event and returns a generator that yields
* the result of each listener in the order of their registration.
* This way, you stop exhausting the listeners once you get the expected value.
*/
*emitAsGenerator(event) {
if (this.listenerCount(event.type) === 0) {
return;
}
const proxiedEvent = this.#proxyEvent(event);
for (const listener of this.#listeners[event.type]) {
if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
return;
}
if (proxiedEvent.event[kImmediatePropagationStopped]) {
break;
}
yield this.#callListener(proxiedEvent.event, listener);
}
proxiedEvent.revoke();
}
/**
* Removes a listener for the given event type.
*/
removeListener(type, listener) {
if (this.listenerCount(type) === 0) {
return;
}
const nextListeners = [];
for (const existingListener of this.#listeners[type]) {
if (existingListener !== listener) {
nextListeners.push(existingListener);
}
}
this.#listeners[type] = nextListeners;
}
/**
* Removes all listeners for the given event type.
* If no event type is provided, removes all existing listeners.
*/
removeAllListeners(type) {
if (type == null) {
this.#listeners = {};
return;
}
this.#listeners[type] = [];
}
/**
* Returns the list of listeners for the given event type.
* If no even type is provided, returns all listeners.
*/
listeners(type) {
if (type == null) {
return Object.values(this.#listeners).flat();
}
return this.#listeners[type] || [];
}
/**
* Returns the number of listeners for the given event type.
* If no even type is provided, returns the total number of listeners.
*/
listenerCount(type) {
return this.listeners(type).length;
}
#addListener(type, listener, options, insertMode = "append") {
this.#listeners[type] ??= [];
if (insertMode === "prepend") {
this.#listeners[type].unshift(listener);
} else {
this.#listeners[type].push(listener);
}
if (options) {
Object.defineProperty(listener, kListenerOptions, {
value: options,
enumerable: false,
writable: false
});
if (options.signal) {
options.signal.addEventListener(
"abort",
() => {
this.removeListener(type, listener);
},
{ once: true }
);
}
}
return this;
}
#proxyEvent(event) {
const { stopPropagation } = event;
event.stopPropagation = new Proxy(event.stopPropagation, {
apply: (target, thisArg,