msw
Version:
1,596 lines (1,553 loc) • 94.4 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/createStartHandler.ts
var import_devUtils7 = 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;
};
// src/browser/setupWorker/start/utils/enableMocking.ts
var import_devUtils3 = require("../core/utils/internal/devUtils");
// 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
async function enableMocking(context, options) {
context.workerChannel.send("MOCK_ACTIVATE");
const { payload } = await context.events.once("MOCKING_ENABLED");
if (context.isMockingEnabled) {
import_devUtils3.devUtils.warn(
`Found a redundant "worker.start()" call. Note that starting the worker while mocking is already enabled will have no effect. Consider removing this "worker.start()" call.`
);
return;
}
context.isMockingEnabled = true;
printStartMessage({
quiet: options.quiet,
workerScope: context.registration?.scope,
workerUrl: context.worker?.scriptURL,
client: payload.client
});
}
// src/browser/setupWorker/start/utils/createMessageChannel.ts
var WorkerChannel = class {
constructor(port) {
this.port = port;
}
postMessage(event, ...rest) {
const [data, transfer] = rest;
this.port.postMessage({ type: event, data }, { transfer });
}
};
// 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_devUtils4 = 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, message) => {
const messageChannel = new WorkerChannel(event.ports[0]);
const requestId = message.payload.id;
const request = deserializeRequest(message.payload);
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() {
messageChannel.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;
messageChannel.postMessage(
"MOCK_RESPONSE",
{
...responseInit,
body: responseStreamOrNull
},
responseStreamOrNull ? [responseStreamOrNull] : void 0
);
} else {
const responseBufferOrNull = response.body === null ? null : await responseClone.arrayBuffer();
messageChannel.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_devUtils4.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
);
messageChannel.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_devUtils5 = require("../core/utils/internal/devUtils");
async function checkWorkerIntegrity(context) {
context.workerChannel.send("INTEGRITY_CHECK_REQUEST");
const { payload } = await context.events.once("INTEGRITY_CHECK_RESPONSE");
if (payload.checksum !== "f5825c521429caf22a4dd13b66e243af") {
import_devUtils5.devUtils.warn(
`The currently registered Service Worker has been generated by a different version of MSW (${payload.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.`
);
}
}
// 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 (_, message) => {
const { payload: responseJson } = message;
const request = deserializeRequest(responseJson.request);
if (responseJson.response.type?.includes("opaque")) {
return;
}
const response = responseJson.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(responseJson.response.status) ? responseJson.response.body : null,
{
...responseJson,
/**
* 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(
responseJson.isMockedResponse ? "response:mocked" : "response:bypass",
{
requestId: responseJson.request.id,
request,
response
}
);
};
}
// src/browser/setupWorker/start/utils/validateWorkerScope.ts
var import_devUtils6 = require("../core/utils/internal/devUtils");
function validateWorkerScope(registration, options) {
if (!options?.quiet && !location.href.startsWith(registration.scope)) {
import_devUtils6.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.events.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_devUtils7.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_devUtils7.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.worker = worker;
context.registration = registration;
context.events.addListener(window, "beforeunload", () => {
if (worker.state !== "redundant") {
context.workerChannel.send("CLIENT_CLOSED");
}
window.clearInterval(context.keepAliveInterval);
window.postMessage({ type: "msw/worker:stop" });
});
await checkWorkerIntegrity(context).catch((error2) => {
import_devUtils7.devUtils.error(
"Error while checking the worker script integrity. Please report this on GitHub (https://github.com/mswjs/msw/issues), including the original error below."
);
console.error(error2);
});
context.keepAliveInterval = window.setInterval(
() => context.workerChannel.send("KEEPALIVE_REQUEST"),
5e3
);
validateWorkerScope(registration, context.startOptions);
return registration;
};
const workerRegistration = startWorkerInstance().then(
async (registration) => {
const pendingInstance = registration.installing || registration.waiting;
if (pendingInstance) {
await new Promise((resolve) => {
pendingInstance.addEventListener("statechange", () => {
if (pendingInstance.state === "activated") {
return resolve();
}
});
});
}
await enableMocking(context, options).catch((error2) => {
throw new Error(`Failed to enable mocking: ${error2?.message}`);
});
return registration;
}
);
return workerRegistration;
};
};
// src/browser/setupWorker/stop/createStop.ts
var import_devUtils9 = require("../core/utils/internal/devUtils");
// src/browser/setupWorker/stop/utils/printStopMessage.ts
var import_devUtils8 = require("../core/utils/internal/devUtils");
function printStopMessage(args = {}) {
if (args.quiet) {
return;
}
console.log(
`%c${import_devUtils8.devUtils.formatMessage("Mocking disabled.")}`,
"color:orangered;font-weight:bold;"
);
}
// src/browser/setupWorker/stop/createStop.ts
var createStop = (context) => {
return function stop() {
if (!context.isMockingEnabled) {
import_devUtils9.devUtils.warn(
'Found a redundant "worker.stop()" call. Note that stopping the worker while mocking already stopped has no effect. Consider removing this "worker.stop()" call.'
);
return;
}
context.workerChannel.send("MOCK_DEACTIVATE");
context.isMockingEnabled = false;
window.clearInterval(context.keepAliveInterval);
window.postMessage({ type: "msw/worker:stop" });
printStopMessage({ quiet: context.startOptions?.quiet });
};
};
// 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;
}
};
// 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 }
});
}
};
// node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-L37TY7LC.mjs
var InterceptorError = class extends Error {
constructor(message) {
super(message);
this.name = "InterceptorError";
Object.setPrototypeOf(this, InterceptorError.prototype);
}
};
var kRequestHandled = Symbol("kRequestHandled");
var kResponsePromise = Symbol("kResponsePromise");
var RequestController = class {
constructor(request) {
this.request = request;
this[kRequestHandled] = false;
this[kResponsePromise] = new DeferredPromise();
}
/**
* Respond to this request with the given `Response` instance.
* @example
* controller.respondWith(new Response())
* controller.respondWith(Response.json({ id }))
* controller.respondWith(Response.error())
*/
respondWith(response) {
invariant.as(
InterceptorError,
!this[kRequestHandled],
'Failed to respond to the "%s %s" request: the "request" event has already been handled.',
this.request.method,
this.request.url
);
this[kRequestHandled] = true;
this[kResponsePromise].resolve(response);
}
/**
* Error this request with the given reason.
*
* @example
* controller.errorWith()
* controller.errorWith(new Error('Oops!'))
* controller.errorWith({ message: 'Oops!'})
*/
errorWith(reason) {
invariant.as(
InterceptorError,
!this[kRequestHandled],
'Failed to error the "%s %s" request: the "request" event has already been handled.',
this.request.method,
this.request.url
);
this[kRequestHandled] = true;
this[kResponsePromise].resolve(reason);
}
};
async function emitAsync(emitter, eventName, ...data) {
const listners = emitter.listeners(eventName);
if (listners.length === 0) {
return;
}
for (const listener of listners) {
await listener.apply(emitter, data);
}
}
function isObject(value, loose = false) {
return loose ? Object.prototype.toString.call(value).startsWith("[object ") : Object.prototype.toString.call(value) === "[object Object]";
}
function isPropertyAccessible(obj, key) {
try {
obj[key];
return true;
} catch (e) {
return false;
}
}
function createServerErrorResponse(body) {
return new Response(
JSON.stringify(
body instanceof Error ? {
name: body.name,
message: body.message,
stack: body.stack
} : body
),
{
status: 500,
statusText: "Unhandled Exception",
headers: {
"Content-Type": "application/json"
}
}
);
}
function isResponseError(response) {
return response != null && response instanceof Response && isPropertyAccessible(response, "type") && response.type === "error";
}
function isResponseLike(value) {
return isObject(value, true) && isPropertyAccessible(value, "status") && isPropertyAccessible(value, "statusText") && isPropertyAccessible(value, "bodyUsed");
}
function isNodeLikeError(error2) {
if (error2 == null) {
return false;
}
if (!(error2 instanceof Error)) {
return false;
}
return "code" in error2 && "errno" in error2;
}
async function handleRequest2(options) {
const handleResponse = async (response) => {
if (response instanceof Error) {
options.onError(response);
return true;
}
if (isResponseError(response)) {
options.onRequestError(response);
return true;
}
if (isResponseLike(response)) {
await options.onResponse(response);
return true;
}
if (isObject(response)) {
options.onError(response);
return true;
}
return false;
};
const handleResponseError = async (error2) => {
if (error2 instanceof InterceptorError) {
throw result.error;
}
if (isNodeLikeError(error2)) {
options.onError(error2);
return true;
}
if (error2 instanceof Response) {
return await handleResponse(error2);
}
return false;
};
options.emitter.once("request", ({ requestId: pendingRequestId }) => {
if (pendingRequestId !== options.requestId) {
return;
}
if (options.controller[kResponsePromise].state === "pending") {
options.controller[kResponsePromise].resolve(void 0);
}
});
const requestAbortPromise = new DeferredPromise();
if (options.request.signal) {
if (options.request.signal.aborted) {
requestAbortPromise.reject(options.request.signal.reason);
} else {
options.request.signal.addEventListener(
"abort",
() => {
requestAbortPromise.reject(options.request.signal.reason);
},
{ once: true }
);
}
}
const result = await until(async () => {
const requestListenersPromise = emitAsync(options.emitter, "request", {
requestId: options.requestId,
request: options.request,
controller: options.controller
});
await Promise.race([
// Short-circuit the request handling promise if the request gets aborted.
requestAbortPromise,
requestListenersPromise,
options.controller[kResponsePromise]
]);
return await options.controller[kResponsePromise];
});
if (requestAbortPromise.state === "rejected") {
options.onError(requestAbortPromise.rejectionReason);
return true;
}
if (result.error) {
if (await handleResponseError(result.error)) {
return true;
}
if (options.emitter.listenerCount("unhandledException") > 0) {
const unhandledExceptionController = new RequestController(
options.request
);
await emitAsync(options.emitter, "unhandledException", {
error: result.error,
request: options.request,
requestId: options.requestId,
controller: unhandledExceptionController
}).then(() => {
if (unhandledExceptionController[kResponsePromise].state === "pending") {
unhandledExceptionController[kResponsePromise].resolve(void 0);
}
});
const nextResult = await until(
() => unhandledExceptionController[kResponsePromise]
);
if (nextResult.error) {
return handleResponseError(nextResult.error);
}
if (nextResult.data) {
return handleResponse(nextResult.data);
}
}
options.onResponse(createServerErrorResponse(result.error));
return true;
}
if (result.data)