Update checked-in dependencies
This commit is contained in:
github-actions[bot]
parent
c9f0d30a86
commit
95d52b7807
647 changed files with 498055 additions and 3880 deletions
846
node_modules/@mswjs/interceptors/lib/browser/chunk-O2RCNIMR.js
generated
vendored
Normal file
846
node_modules/@mswjs/interceptors/lib/browser/chunk-O2RCNIMR.js
generated
vendored
Normal file
|
|
@ -0,0 +1,846 @@
|
|||
"use strict";Object.defineProperty(exports, "__esModule", {value: true});
|
||||
|
||||
|
||||
|
||||
var _chunkLK6DILFKjs = require('./chunk-LK6DILFK.js');
|
||||
|
||||
|
||||
|
||||
var _chunkGTJ35JP4js = require('./chunk-GTJ35JP4.js');
|
||||
|
||||
|
||||
|
||||
|
||||
var _chunkMSUVVHIGjs = require('./chunk-MSUVVHIG.js');
|
||||
|
||||
|
||||
var _chunkPFGO5BSMjs = require('./chunk-PFGO5BSM.js');
|
||||
|
||||
|
||||
|
||||
|
||||
var _chunkTIPR373Rjs = require('./chunk-TIPR373R.js');
|
||||
|
||||
// src/interceptors/XMLHttpRequest/index.ts
|
||||
var _outvariant = require('outvariant');
|
||||
|
||||
// src/interceptors/XMLHttpRequest/XMLHttpRequestController.ts
|
||||
|
||||
var _isnodeprocess = require('is-node-process');
|
||||
|
||||
// src/interceptors/XMLHttpRequest/utils/concatArrayBuffer.ts
|
||||
function concatArrayBuffer(left, right) {
|
||||
const result = new Uint8Array(left.byteLength + right.byteLength);
|
||||
result.set(left, 0);
|
||||
result.set(right, left.byteLength);
|
||||
return result;
|
||||
}
|
||||
|
||||
// src/interceptors/XMLHttpRequest/polyfills/EventPolyfill.ts
|
||||
var EventPolyfill = class {
|
||||
constructor(type, options) {
|
||||
this.NONE = 0;
|
||||
this.CAPTURING_PHASE = 1;
|
||||
this.AT_TARGET = 2;
|
||||
this.BUBBLING_PHASE = 3;
|
||||
this.type = "";
|
||||
this.srcElement = null;
|
||||
this.currentTarget = null;
|
||||
this.eventPhase = 0;
|
||||
this.isTrusted = true;
|
||||
this.composed = false;
|
||||
this.cancelable = true;
|
||||
this.defaultPrevented = false;
|
||||
this.bubbles = true;
|
||||
this.lengthComputable = true;
|
||||
this.loaded = 0;
|
||||
this.total = 0;
|
||||
this.cancelBubble = false;
|
||||
this.returnValue = true;
|
||||
this.type = type;
|
||||
this.target = (options == null ? void 0 : options.target) || null;
|
||||
this.currentTarget = (options == null ? void 0 : options.currentTarget) || null;
|
||||
this.timeStamp = Date.now();
|
||||
}
|
||||
composedPath() {
|
||||
return [];
|
||||
}
|
||||
initEvent(type, bubbles, cancelable) {
|
||||
this.type = type;
|
||||
this.bubbles = !!bubbles;
|
||||
this.cancelable = !!cancelable;
|
||||
}
|
||||
preventDefault() {
|
||||
this.defaultPrevented = true;
|
||||
}
|
||||
stopPropagation() {
|
||||
}
|
||||
stopImmediatePropagation() {
|
||||
}
|
||||
};
|
||||
|
||||
// src/interceptors/XMLHttpRequest/polyfills/ProgressEventPolyfill.ts
|
||||
var ProgressEventPolyfill = class extends EventPolyfill {
|
||||
constructor(type, init) {
|
||||
super(type);
|
||||
this.lengthComputable = (init == null ? void 0 : init.lengthComputable) || false;
|
||||
this.composed = (init == null ? void 0 : init.composed) || false;
|
||||
this.loaded = (init == null ? void 0 : init.loaded) || 0;
|
||||
this.total = (init == null ? void 0 : init.total) || 0;
|
||||
}
|
||||
};
|
||||
|
||||
// src/interceptors/XMLHttpRequest/utils/createEvent.ts
|
||||
var SUPPORTS_PROGRESS_EVENT = typeof ProgressEvent !== "undefined";
|
||||
function createEvent(target, type, init) {
|
||||
const progressEvents = [
|
||||
"error",
|
||||
"progress",
|
||||
"loadstart",
|
||||
"loadend",
|
||||
"load",
|
||||
"timeout",
|
||||
"abort"
|
||||
];
|
||||
const ProgressEventClass = SUPPORTS_PROGRESS_EVENT ? ProgressEvent : ProgressEventPolyfill;
|
||||
const event = progressEvents.includes(type) ? new ProgressEventClass(type, {
|
||||
lengthComputable: true,
|
||||
loaded: (init == null ? void 0 : init.loaded) || 0,
|
||||
total: (init == null ? void 0 : init.total) || 0
|
||||
}) : new EventPolyfill(type, {
|
||||
target,
|
||||
currentTarget: target
|
||||
});
|
||||
return event;
|
||||
}
|
||||
|
||||
// src/utils/findPropertySource.ts
|
||||
function findPropertySource(target, propertyName) {
|
||||
if (!(propertyName in target)) {
|
||||
return null;
|
||||
}
|
||||
const hasProperty = Object.prototype.hasOwnProperty.call(target, propertyName);
|
||||
if (hasProperty) {
|
||||
return target;
|
||||
}
|
||||
const prototype = Reflect.getPrototypeOf(target);
|
||||
return prototype ? findPropertySource(prototype, propertyName) : null;
|
||||
}
|
||||
|
||||
// src/utils/createProxy.ts
|
||||
function createProxy(target, options) {
|
||||
const proxy = new Proxy(target, optionsToProxyHandler(options));
|
||||
return proxy;
|
||||
}
|
||||
function optionsToProxyHandler(options) {
|
||||
const { constructorCall, methodCall, getProperty, setProperty } = options;
|
||||
const handler = {};
|
||||
if (typeof constructorCall !== "undefined") {
|
||||
handler.construct = function(target, args, newTarget) {
|
||||
const next = Reflect.construct.bind(null, target, args, newTarget);
|
||||
return constructorCall.call(newTarget, args, next);
|
||||
};
|
||||
}
|
||||
handler.set = function(target, propertyName, nextValue) {
|
||||
const next = () => {
|
||||
const propertySource = findPropertySource(target, propertyName) || target;
|
||||
const ownDescriptors = Reflect.getOwnPropertyDescriptor(
|
||||
propertySource,
|
||||
propertyName
|
||||
);
|
||||
if (typeof (ownDescriptors == null ? void 0 : ownDescriptors.set) !== "undefined") {
|
||||
ownDescriptors.set.apply(target, [nextValue]);
|
||||
return true;
|
||||
}
|
||||
return Reflect.defineProperty(propertySource, propertyName, {
|
||||
writable: true,
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
value: nextValue
|
||||
});
|
||||
};
|
||||
if (typeof setProperty !== "undefined") {
|
||||
return setProperty.call(target, [propertyName, nextValue], next);
|
||||
}
|
||||
return next();
|
||||
};
|
||||
handler.get = function(target, propertyName, receiver) {
|
||||
const next = () => target[propertyName];
|
||||
const value = typeof getProperty !== "undefined" ? getProperty.call(target, [propertyName, receiver], next) : next();
|
||||
if (typeof value === "function") {
|
||||
return (...args) => {
|
||||
const next2 = value.bind(target, ...args);
|
||||
if (typeof methodCall !== "undefined") {
|
||||
return methodCall.call(target, [propertyName, args], next2);
|
||||
}
|
||||
return next2();
|
||||
};
|
||||
}
|
||||
return value;
|
||||
};
|
||||
return handler;
|
||||
}
|
||||
|
||||
// src/interceptors/XMLHttpRequest/utils/isDomParserSupportedType.ts
|
||||
function isDomParserSupportedType(type) {
|
||||
const supportedTypes = [
|
||||
"application/xhtml+xml",
|
||||
"application/xml",
|
||||
"image/svg+xml",
|
||||
"text/html",
|
||||
"text/xml"
|
||||
];
|
||||
return supportedTypes.some((supportedType) => {
|
||||
return type.startsWith(supportedType);
|
||||
});
|
||||
}
|
||||
|
||||
// src/utils/parseJson.ts
|
||||
function parseJson(data) {
|
||||
try {
|
||||
const json = JSON.parse(data);
|
||||
return json;
|
||||
} catch (_) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// src/interceptors/XMLHttpRequest/utils/createResponse.ts
|
||||
function createResponse(request, body) {
|
||||
const responseBodyOrNull = _chunkMSUVVHIGjs.FetchResponse.isResponseWithBody(request.status) ? body : null;
|
||||
return new (0, _chunkMSUVVHIGjs.FetchResponse)(responseBodyOrNull, {
|
||||
url: request.responseURL,
|
||||
status: request.status,
|
||||
statusText: request.statusText,
|
||||
headers: createHeadersFromXMLHttpReqestHeaders(
|
||||
request.getAllResponseHeaders()
|
||||
)
|
||||
});
|
||||
}
|
||||
function createHeadersFromXMLHttpReqestHeaders(headersString) {
|
||||
const headers = new Headers();
|
||||
const lines = headersString.split(/[\r\n]+/);
|
||||
for (const line of lines) {
|
||||
if (line.trim() === "") {
|
||||
continue;
|
||||
}
|
||||
const [name, ...parts] = line.split(": ");
|
||||
const value = parts.join(": ");
|
||||
headers.append(name, value);
|
||||
}
|
||||
return headers;
|
||||
}
|
||||
|
||||
// src/interceptors/XMLHttpRequest/utils/getBodyByteLength.ts
|
||||
async function getBodyByteLength(input) {
|
||||
const explicitContentLength = input.headers.get("content-length");
|
||||
if (explicitContentLength != null && explicitContentLength !== "") {
|
||||
return Number(explicitContentLength);
|
||||
}
|
||||
const buffer = await input.arrayBuffer();
|
||||
return buffer.byteLength;
|
||||
}
|
||||
|
||||
// src/interceptors/XMLHttpRequest/XMLHttpRequestController.ts
|
||||
var kIsRequestHandled = Symbol("kIsRequestHandled");
|
||||
var IS_NODE = _isnodeprocess.isNodeProcess.call(void 0, );
|
||||
var kFetchRequest = Symbol("kFetchRequest");
|
||||
var XMLHttpRequestController = class {
|
||||
constructor(initialRequest, logger) {
|
||||
this.initialRequest = initialRequest;
|
||||
this.logger = logger;
|
||||
this.method = "GET";
|
||||
this.url = null;
|
||||
this[kIsRequestHandled] = false;
|
||||
this.events = /* @__PURE__ */ new Map();
|
||||
this.uploadEvents = /* @__PURE__ */ new Map();
|
||||
this.requestId = _chunkTIPR373Rjs.createRequestId.call(void 0, );
|
||||
this.requestHeaders = new Headers();
|
||||
this.responseBuffer = new Uint8Array();
|
||||
this.request = createProxy(initialRequest, {
|
||||
setProperty: ([propertyName, nextValue], invoke) => {
|
||||
switch (propertyName) {
|
||||
case "ontimeout": {
|
||||
const eventName = propertyName.slice(
|
||||
2
|
||||
);
|
||||
this.request.addEventListener(eventName, nextValue);
|
||||
return invoke();
|
||||
}
|
||||
default: {
|
||||
return invoke();
|
||||
}
|
||||
}
|
||||
},
|
||||
methodCall: ([methodName, args], invoke) => {
|
||||
var _a;
|
||||
switch (methodName) {
|
||||
case "open": {
|
||||
const [method, url] = args;
|
||||
if (typeof url === "undefined") {
|
||||
this.method = "GET";
|
||||
this.url = toAbsoluteUrl(method);
|
||||
} else {
|
||||
this.method = method;
|
||||
this.url = toAbsoluteUrl(url);
|
||||
}
|
||||
this.logger = this.logger.extend(`${this.method} ${this.url.href}`);
|
||||
this.logger.info("open", this.method, this.url.href);
|
||||
return invoke();
|
||||
}
|
||||
case "addEventListener": {
|
||||
const [eventName, listener] = args;
|
||||
this.registerEvent(eventName, listener);
|
||||
this.logger.info("addEventListener", eventName, listener);
|
||||
return invoke();
|
||||
}
|
||||
case "setRequestHeader": {
|
||||
const [name, value] = args;
|
||||
this.requestHeaders.set(name, value);
|
||||
this.logger.info("setRequestHeader", name, value);
|
||||
return invoke();
|
||||
}
|
||||
case "send": {
|
||||
const [body] = args;
|
||||
this.request.addEventListener("load", () => {
|
||||
if (typeof this.onResponse !== "undefined") {
|
||||
const fetchResponse = createResponse(
|
||||
this.request,
|
||||
/**
|
||||
* The `response` property is the right way to read
|
||||
* the ambiguous response body, as the request's "responseType" may differ.
|
||||
* @see https://xhr.spec.whatwg.org/#the-response-attribute
|
||||
*/
|
||||
this.request.response
|
||||
);
|
||||
this.onResponse.call(this, {
|
||||
response: fetchResponse,
|
||||
isMockedResponse: this[kIsRequestHandled],
|
||||
request: fetchRequest,
|
||||
requestId: this.requestId
|
||||
});
|
||||
}
|
||||
});
|
||||
const requestBody = typeof body === "string" ? _chunkLK6DILFKjs.encodeBuffer.call(void 0, body) : body;
|
||||
const fetchRequest = this.toFetchApiRequest(requestBody);
|
||||
this[kFetchRequest] = fetchRequest.clone();
|
||||
const onceRequestSettled = ((_a = this.onRequest) == null ? void 0 : _a.call(this, {
|
||||
request: fetchRequest,
|
||||
requestId: this.requestId
|
||||
})) || Promise.resolve();
|
||||
onceRequestSettled.finally(() => {
|
||||
if (!this[kIsRequestHandled]) {
|
||||
this.logger.info(
|
||||
"request callback settled but request has not been handled (readystate %d), performing as-is...",
|
||||
this.request.readyState
|
||||
);
|
||||
if (IS_NODE) {
|
||||
this.request.setRequestHeader(
|
||||
_chunkTIPR373Rjs.INTERNAL_REQUEST_ID_HEADER_NAME,
|
||||
this.requestId
|
||||
);
|
||||
}
|
||||
return invoke();
|
||||
}
|
||||
});
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
return invoke();
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
define(
|
||||
this.request,
|
||||
"upload",
|
||||
createProxy(this.request.upload, {
|
||||
setProperty: ([propertyName, nextValue], invoke) => {
|
||||
switch (propertyName) {
|
||||
case "onloadstart":
|
||||
case "onprogress":
|
||||
case "onaboart":
|
||||
case "onerror":
|
||||
case "onload":
|
||||
case "ontimeout":
|
||||
case "onloadend": {
|
||||
const eventName = propertyName.slice(
|
||||
2
|
||||
);
|
||||
this.registerUploadEvent(eventName, nextValue);
|
||||
}
|
||||
}
|
||||
return invoke();
|
||||
},
|
||||
methodCall: ([methodName, args], invoke) => {
|
||||
switch (methodName) {
|
||||
case "addEventListener": {
|
||||
const [eventName, listener] = args;
|
||||
this.registerUploadEvent(eventName, listener);
|
||||
this.logger.info("upload.addEventListener", eventName, listener);
|
||||
return invoke();
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
);
|
||||
}
|
||||
registerEvent(eventName, listener) {
|
||||
const prevEvents = this.events.get(eventName) || [];
|
||||
const nextEvents = prevEvents.concat(listener);
|
||||
this.events.set(eventName, nextEvents);
|
||||
this.logger.info('registered event "%s"', eventName, listener);
|
||||
}
|
||||
registerUploadEvent(eventName, listener) {
|
||||
const prevEvents = this.uploadEvents.get(eventName) || [];
|
||||
const nextEvents = prevEvents.concat(listener);
|
||||
this.uploadEvents.set(eventName, nextEvents);
|
||||
this.logger.info('registered upload event "%s"', eventName, listener);
|
||||
}
|
||||
/**
|
||||
* Responds to the current request with the given
|
||||
* Fetch API `Response` instance.
|
||||
*/
|
||||
async respondWith(response) {
|
||||
this[kIsRequestHandled] = true;
|
||||
if (this[kFetchRequest]) {
|
||||
const totalRequestBodyLength = await getBodyByteLength(
|
||||
this[kFetchRequest]
|
||||
);
|
||||
this.trigger("loadstart", this.request.upload, {
|
||||
loaded: 0,
|
||||
total: totalRequestBodyLength
|
||||
});
|
||||
this.trigger("progress", this.request.upload, {
|
||||
loaded: totalRequestBodyLength,
|
||||
total: totalRequestBodyLength
|
||||
});
|
||||
this.trigger("load", this.request.upload, {
|
||||
loaded: totalRequestBodyLength,
|
||||
total: totalRequestBodyLength
|
||||
});
|
||||
this.trigger("loadend", this.request.upload, {
|
||||
loaded: totalRequestBodyLength,
|
||||
total: totalRequestBodyLength
|
||||
});
|
||||
}
|
||||
this.logger.info(
|
||||
"responding with a mocked response: %d %s",
|
||||
response.status,
|
||||
response.statusText
|
||||
);
|
||||
define(this.request, "status", response.status);
|
||||
define(this.request, "statusText", response.statusText);
|
||||
define(this.request, "responseURL", this.url.href);
|
||||
this.request.getResponseHeader = new Proxy(this.request.getResponseHeader, {
|
||||
apply: (_, __, args) => {
|
||||
this.logger.info("getResponseHeader", args[0]);
|
||||
if (this.request.readyState < this.request.HEADERS_RECEIVED) {
|
||||
this.logger.info("headers not received yet, returning null");
|
||||
return null;
|
||||
}
|
||||
const headerValue = response.headers.get(args[0]);
|
||||
this.logger.info(
|
||||
'resolved response header "%s" to',
|
||||
args[0],
|
||||
headerValue
|
||||
);
|
||||
return headerValue;
|
||||
}
|
||||
});
|
||||
this.request.getAllResponseHeaders = new Proxy(
|
||||
this.request.getAllResponseHeaders,
|
||||
{
|
||||
apply: () => {
|
||||
this.logger.info("getAllResponseHeaders");
|
||||
if (this.request.readyState < this.request.HEADERS_RECEIVED) {
|
||||
this.logger.info("headers not received yet, returning empty string");
|
||||
return "";
|
||||
}
|
||||
const headersList = Array.from(response.headers.entries());
|
||||
const allHeaders = headersList.map(([headerName, headerValue]) => {
|
||||
return `${headerName}: ${headerValue}`;
|
||||
}).join("\r\n");
|
||||
this.logger.info("resolved all response headers to", allHeaders);
|
||||
return allHeaders;
|
||||
}
|
||||
}
|
||||
);
|
||||
Object.defineProperties(this.request, {
|
||||
response: {
|
||||
enumerable: true,
|
||||
configurable: false,
|
||||
get: () => this.response
|
||||
},
|
||||
responseText: {
|
||||
enumerable: true,
|
||||
configurable: false,
|
||||
get: () => this.responseText
|
||||
},
|
||||
responseXML: {
|
||||
enumerable: true,
|
||||
configurable: false,
|
||||
get: () => this.responseXML
|
||||
}
|
||||
});
|
||||
const totalResponseBodyLength = await getBodyByteLength(response.clone());
|
||||
this.logger.info("calculated response body length", totalResponseBodyLength);
|
||||
this.trigger("loadstart", this.request, {
|
||||
loaded: 0,
|
||||
total: totalResponseBodyLength
|
||||
});
|
||||
this.setReadyState(this.request.HEADERS_RECEIVED);
|
||||
this.setReadyState(this.request.LOADING);
|
||||
const finalizeResponse = () => {
|
||||
this.logger.info("finalizing the mocked response...");
|
||||
this.setReadyState(this.request.DONE);
|
||||
this.trigger("load", this.request, {
|
||||
loaded: this.responseBuffer.byteLength,
|
||||
total: totalResponseBodyLength
|
||||
});
|
||||
this.trigger("loadend", this.request, {
|
||||
loaded: this.responseBuffer.byteLength,
|
||||
total: totalResponseBodyLength
|
||||
});
|
||||
};
|
||||
if (response.body) {
|
||||
this.logger.info("mocked response has body, streaming...");
|
||||
const reader = response.body.getReader();
|
||||
const readNextResponseBodyChunk = async () => {
|
||||
const { value, done } = await reader.read();
|
||||
if (done) {
|
||||
this.logger.info("response body stream done!");
|
||||
finalizeResponse();
|
||||
return;
|
||||
}
|
||||
if (value) {
|
||||
this.logger.info("read response body chunk:", value);
|
||||
this.responseBuffer = concatArrayBuffer(this.responseBuffer, value);
|
||||
this.trigger("progress", this.request, {
|
||||
loaded: this.responseBuffer.byteLength,
|
||||
total: totalResponseBodyLength
|
||||
});
|
||||
}
|
||||
readNextResponseBodyChunk();
|
||||
};
|
||||
readNextResponseBodyChunk();
|
||||
} else {
|
||||
finalizeResponse();
|
||||
}
|
||||
}
|
||||
responseBufferToText() {
|
||||
return _chunkLK6DILFKjs.decodeBuffer.call(void 0, this.responseBuffer);
|
||||
}
|
||||
get response() {
|
||||
this.logger.info(
|
||||
"getResponse (responseType: %s)",
|
||||
this.request.responseType
|
||||
);
|
||||
if (this.request.readyState !== this.request.DONE) {
|
||||
return null;
|
||||
}
|
||||
switch (this.request.responseType) {
|
||||
case "json": {
|
||||
const responseJson = parseJson(this.responseBufferToText());
|
||||
this.logger.info("resolved response JSON", responseJson);
|
||||
return responseJson;
|
||||
}
|
||||
case "arraybuffer": {
|
||||
const arrayBuffer = _chunkLK6DILFKjs.toArrayBuffer.call(void 0, this.responseBuffer);
|
||||
this.logger.info("resolved response ArrayBuffer", arrayBuffer);
|
||||
return arrayBuffer;
|
||||
}
|
||||
case "blob": {
|
||||
const mimeType = this.request.getResponseHeader("Content-Type") || "text/plain";
|
||||
const responseBlob = new Blob([this.responseBufferToText()], {
|
||||
type: mimeType
|
||||
});
|
||||
this.logger.info(
|
||||
"resolved response Blob (mime type: %s)",
|
||||
responseBlob,
|
||||
mimeType
|
||||
);
|
||||
return responseBlob;
|
||||
}
|
||||
default: {
|
||||
const responseText = this.responseBufferToText();
|
||||
this.logger.info(
|
||||
'resolving "%s" response type as text',
|
||||
this.request.responseType,
|
||||
responseText
|
||||
);
|
||||
return responseText;
|
||||
}
|
||||
}
|
||||
}
|
||||
get responseText() {
|
||||
_outvariant.invariant.call(void 0,
|
||||
this.request.responseType === "" || this.request.responseType === "text",
|
||||
"InvalidStateError: The object is in invalid state."
|
||||
);
|
||||
if (this.request.readyState !== this.request.LOADING && this.request.readyState !== this.request.DONE) {
|
||||
return "";
|
||||
}
|
||||
const responseText = this.responseBufferToText();
|
||||
this.logger.info('getResponseText: "%s"', responseText);
|
||||
return responseText;
|
||||
}
|
||||
get responseXML() {
|
||||
_outvariant.invariant.call(void 0,
|
||||
this.request.responseType === "" || this.request.responseType === "document",
|
||||
"InvalidStateError: The object is in invalid state."
|
||||
);
|
||||
if (this.request.readyState !== this.request.DONE) {
|
||||
return null;
|
||||
}
|
||||
const contentType = this.request.getResponseHeader("Content-Type") || "";
|
||||
if (typeof DOMParser === "undefined") {
|
||||
console.warn(
|
||||
"Cannot retrieve XMLHttpRequest response body as XML: DOMParser is not defined. You are likely using an environment that is not browser or does not polyfill browser globals correctly."
|
||||
);
|
||||
return null;
|
||||
}
|
||||
if (isDomParserSupportedType(contentType)) {
|
||||
return new DOMParser().parseFromString(
|
||||
this.responseBufferToText(),
|
||||
contentType
|
||||
);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
errorWith(error) {
|
||||
this[kIsRequestHandled] = true;
|
||||
this.logger.info("responding with an error");
|
||||
this.setReadyState(this.request.DONE);
|
||||
this.trigger("error", this.request);
|
||||
this.trigger("loadend", this.request);
|
||||
}
|
||||
/**
|
||||
* Transitions this request's `readyState` to the given one.
|
||||
*/
|
||||
setReadyState(nextReadyState) {
|
||||
this.logger.info(
|
||||
"setReadyState: %d -> %d",
|
||||
this.request.readyState,
|
||||
nextReadyState
|
||||
);
|
||||
if (this.request.readyState === nextReadyState) {
|
||||
this.logger.info("ready state identical, skipping transition...");
|
||||
return;
|
||||
}
|
||||
define(this.request, "readyState", nextReadyState);
|
||||
this.logger.info("set readyState to: %d", nextReadyState);
|
||||
if (nextReadyState !== this.request.UNSENT) {
|
||||
this.logger.info('triggerring "readystatechange" event...');
|
||||
this.trigger("readystatechange", this.request);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Triggers given event on the `XMLHttpRequest` instance.
|
||||
*/
|
||||
trigger(eventName, target, options) {
|
||||
const callback = target[`on${eventName}`];
|
||||
const event = createEvent(target, eventName, options);
|
||||
this.logger.info('trigger "%s"', eventName, options || "");
|
||||
if (typeof callback === "function") {
|
||||
this.logger.info('found a direct "%s" callback, calling...', eventName);
|
||||
callback.call(target, event);
|
||||
}
|
||||
const events = target instanceof XMLHttpRequestUpload ? this.uploadEvents : this.events;
|
||||
for (const [registeredEventName, listeners] of events) {
|
||||
if (registeredEventName === eventName) {
|
||||
this.logger.info(
|
||||
'found %d listener(s) for "%s" event, calling...',
|
||||
listeners.length,
|
||||
eventName
|
||||
);
|
||||
listeners.forEach((listener) => listener.call(target, event));
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Converts this `XMLHttpRequest` instance into a Fetch API `Request` instance.
|
||||
*/
|
||||
toFetchApiRequest(body) {
|
||||
this.logger.info("converting request to a Fetch API Request...");
|
||||
const resolvedBody = body instanceof Document ? body.documentElement.innerText : body;
|
||||
const fetchRequest = new Request(this.url.href, {
|
||||
method: this.method,
|
||||
headers: this.requestHeaders,
|
||||
/**
|
||||
* @see https://xhr.spec.whatwg.org/#cross-origin-credentials
|
||||
*/
|
||||
credentials: this.request.withCredentials ? "include" : "same-origin",
|
||||
body: ["GET", "HEAD"].includes(this.method.toUpperCase()) ? null : resolvedBody
|
||||
});
|
||||
const proxyHeaders = createProxy(fetchRequest.headers, {
|
||||
methodCall: ([methodName, args], invoke) => {
|
||||
switch (methodName) {
|
||||
case "append":
|
||||
case "set": {
|
||||
const [headerName, headerValue] = args;
|
||||
this.request.setRequestHeader(headerName, headerValue);
|
||||
break;
|
||||
}
|
||||
case "delete": {
|
||||
const [headerName] = args;
|
||||
console.warn(
|
||||
`XMLHttpRequest: Cannot remove a "${headerName}" header from the Fetch API representation of the "${fetchRequest.method} ${fetchRequest.url}" request. XMLHttpRequest headers cannot be removed.`
|
||||
);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return invoke();
|
||||
}
|
||||
});
|
||||
define(fetchRequest, "headers", proxyHeaders);
|
||||
_chunkMSUVVHIGjs.setRawRequest.call(void 0, fetchRequest, this.request);
|
||||
this.logger.info("converted request to a Fetch API Request!", fetchRequest);
|
||||
return fetchRequest;
|
||||
}
|
||||
};
|
||||
kIsRequestHandled, kFetchRequest;
|
||||
function toAbsoluteUrl(url) {
|
||||
if (typeof location === "undefined") {
|
||||
return new URL(url);
|
||||
}
|
||||
return new URL(url.toString(), location.href);
|
||||
}
|
||||
function define(target, property, value) {
|
||||
Reflect.defineProperty(target, property, {
|
||||
// Ensure writable properties to allow redefining readonly properties.
|
||||
writable: true,
|
||||
enumerable: true,
|
||||
value
|
||||
});
|
||||
}
|
||||
|
||||
// src/interceptors/XMLHttpRequest/XMLHttpRequestProxy.ts
|
||||
function createXMLHttpRequestProxy({
|
||||
emitter,
|
||||
logger
|
||||
}) {
|
||||
const XMLHttpRequestProxy = new Proxy(globalThis.XMLHttpRequest, {
|
||||
construct(target, args, newTarget) {
|
||||
logger.info("constructed new XMLHttpRequest");
|
||||
const originalRequest = Reflect.construct(
|
||||
target,
|
||||
args,
|
||||
newTarget
|
||||
);
|
||||
const prototypeDescriptors = Object.getOwnPropertyDescriptors(
|
||||
target.prototype
|
||||
);
|
||||
for (const propertyName in prototypeDescriptors) {
|
||||
Reflect.defineProperty(
|
||||
originalRequest,
|
||||
propertyName,
|
||||
prototypeDescriptors[propertyName]
|
||||
);
|
||||
}
|
||||
const xhrRequestController = new XMLHttpRequestController(
|
||||
originalRequest,
|
||||
logger
|
||||
);
|
||||
xhrRequestController.onRequest = async function({ request, requestId }) {
|
||||
const controller = new (0, _chunkGTJ35JP4js.RequestController)(request);
|
||||
this.logger.info("awaiting mocked response...");
|
||||
this.logger.info(
|
||||
'emitting the "request" event for %s listener(s)...',
|
||||
emitter.listenerCount("request")
|
||||
);
|
||||
const isRequestHandled = await _chunkGTJ35JP4js.handleRequest.call(void 0, {
|
||||
request,
|
||||
requestId,
|
||||
controller,
|
||||
emitter,
|
||||
onResponse: async (response) => {
|
||||
await this.respondWith(response);
|
||||
},
|
||||
onRequestError: () => {
|
||||
this.errorWith(new TypeError("Network error"));
|
||||
},
|
||||
onError: (error) => {
|
||||
this.logger.info("request errored!", { error });
|
||||
if (error instanceof Error) {
|
||||
this.errorWith(error);
|
||||
}
|
||||
}
|
||||
});
|
||||
if (!isRequestHandled) {
|
||||
this.logger.info(
|
||||
"no mocked response received, performing request as-is..."
|
||||
);
|
||||
}
|
||||
};
|
||||
xhrRequestController.onResponse = async function({
|
||||
response,
|
||||
isMockedResponse,
|
||||
request,
|
||||
requestId
|
||||
}) {
|
||||
this.logger.info(
|
||||
'emitting the "response" event for %s listener(s)...',
|
||||
emitter.listenerCount("response")
|
||||
);
|
||||
emitter.emit("response", {
|
||||
response,
|
||||
isMockedResponse,
|
||||
request,
|
||||
requestId
|
||||
});
|
||||
};
|
||||
return xhrRequestController.request;
|
||||
}
|
||||
});
|
||||
return XMLHttpRequestProxy;
|
||||
}
|
||||
|
||||
// src/interceptors/XMLHttpRequest/index.ts
|
||||
var _XMLHttpRequestInterceptor = class extends _chunkTIPR373Rjs.Interceptor {
|
||||
constructor() {
|
||||
super(_XMLHttpRequestInterceptor.interceptorSymbol);
|
||||
}
|
||||
checkEnvironment() {
|
||||
return _chunkPFGO5BSMjs.hasConfigurableGlobal.call(void 0, "XMLHttpRequest");
|
||||
}
|
||||
setup() {
|
||||
const logger = this.logger.extend("setup");
|
||||
logger.info('patching "XMLHttpRequest" module...');
|
||||
const PureXMLHttpRequest = globalThis.XMLHttpRequest;
|
||||
_outvariant.invariant.call(void 0,
|
||||
!PureXMLHttpRequest[_chunkMSUVVHIGjs.IS_PATCHED_MODULE],
|
||||
'Failed to patch the "XMLHttpRequest" module: already patched.'
|
||||
);
|
||||
globalThis.XMLHttpRequest = createXMLHttpRequestProxy({
|
||||
emitter: this.emitter,
|
||||
logger: this.logger
|
||||
});
|
||||
logger.info(
|
||||
'native "XMLHttpRequest" module patched!',
|
||||
globalThis.XMLHttpRequest.name
|
||||
);
|
||||
Object.defineProperty(globalThis.XMLHttpRequest, _chunkMSUVVHIGjs.IS_PATCHED_MODULE, {
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
value: true
|
||||
});
|
||||
this.subscriptions.push(() => {
|
||||
Object.defineProperty(globalThis.XMLHttpRequest, _chunkMSUVVHIGjs.IS_PATCHED_MODULE, {
|
||||
value: void 0
|
||||
});
|
||||
globalThis.XMLHttpRequest = PureXMLHttpRequest;
|
||||
logger.info(
|
||||
'native "XMLHttpRequest" module restored!',
|
||||
globalThis.XMLHttpRequest.name
|
||||
);
|
||||
});
|
||||
}
|
||||
};
|
||||
var XMLHttpRequestInterceptor = _XMLHttpRequestInterceptor;
|
||||
XMLHttpRequestInterceptor.interceptorSymbol = Symbol("xhr");
|
||||
|
||||
|
||||
|
||||
exports.XMLHttpRequestInterceptor = XMLHttpRequestInterceptor;
|
||||
//# sourceMappingURL=chunk-O2RCNIMR.js.map
|
||||
Loading…
Add table
Add a link
Reference in a new issue