| Linux premium331.web-hosting.com 4.18.0-553.80.1.lve.el8.x86_64 #1 SMP Wed Oct 22 19:29:36 UTC 2025 x86_64 Path : /home/livedhms/lmgt/node_modules/next/dist/server/lib/ |
| Current File : //home/livedhms/lmgt/node_modules/next/dist/server/lib/mock-request.js |
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && (module.exports = {
MockedRequest: null,
MockedResponse: null,
createRequestResponseMocks: null
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
MockedRequest: function() {
return MockedRequest;
},
MockedResponse: function() {
return MockedResponse;
},
createRequestResponseMocks: function() {
return createRequestResponseMocks;
}
});
const _stream = /*#__PURE__*/ _interop_require_default(require("stream"));
const _utils = require("../web/utils");
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
class MockedRequest extends _stream.default.Readable {
constructor({ url, headers, method, socket = null, readable }){
super(), // This is hardcoded for now, but can be updated to be configurable if needed.
this.httpVersion = '1.0', this.httpVersionMajor = 1, this.httpVersionMinor = 0, // If we don't actually have a socket, we'll just use a mock one that
// always returns false for the `encrypted` property and undefined for the
// `remoteAddress` property.
this.socket = new Proxy({}, {
get: (_target, prop)=>{
if (prop !== 'encrypted' && prop !== 'remoteAddress') {
throw Object.defineProperty(new Error('Method not implemented'), "__NEXT_ERROR_CODE", {
value: "E52",
enumerable: false,
configurable: true
});
}
if (prop === 'remoteAddress') return undefined;
// For this mock request, always ensure we just respond with the encrypted
// set to false to ensure there's no odd leakages.
return false;
}
});
this.url = url;
this.headers = headers;
this.method = method;
if (readable) {
this.bodyReadable = readable;
this.bodyReadable.on('end', ()=>this.emit('end'));
this.bodyReadable.on('close', ()=>this.emit('close'));
}
if (socket) {
this.socket = socket;
}
}
get headersDistinct() {
const headers = {};
for (const [key, value] of Object.entries(this.headers)){
if (!value) continue;
headers[key] = Array.isArray(value) ? value : [
value
];
}
return headers;
}
_read(size) {
if (this.bodyReadable) {
return this.bodyReadable._read(size);
} else {
this.emit('end');
this.emit('close');
}
}
/**
* The `connection` property is just an alias for the `socket` property.
*
* @deprecated — since v13.0.0 - Use socket instead.
*/ get connection() {
return this.socket;
}
// The following methods are not implemented as they are not used in the
// Next.js codebase.
get aborted() {
throw Object.defineProperty(new Error('Method not implemented'), "__NEXT_ERROR_CODE", {
value: "E52",
enumerable: false,
configurable: true
});
}
get complete() {
throw Object.defineProperty(new Error('Method not implemented'), "__NEXT_ERROR_CODE", {
value: "E52",
enumerable: false,
configurable: true
});
}
get trailers() {
throw Object.defineProperty(new Error('Method not implemented'), "__NEXT_ERROR_CODE", {
value: "E52",
enumerable: false,
configurable: true
});
}
get trailersDistinct() {
throw Object.defineProperty(new Error('Method not implemented'), "__NEXT_ERROR_CODE", {
value: "E52",
enumerable: false,
configurable: true
});
}
get rawTrailers() {
throw Object.defineProperty(new Error('Method not implemented'), "__NEXT_ERROR_CODE", {
value: "E52",
enumerable: false,
configurable: true
});
}
get rawHeaders() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
setTimeout() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
}
class MockedResponse extends _stream.default.Writable {
constructor(res = {}){
super(), this.statusMessage = '', this.finished = false, this.headersSent = false, /**
* A list of buffers that have been written to the response.
*
* @internal - used internally by Next.js
*/ this.buffers = [];
this.statusCode = res.statusCode ?? 200;
this.socket = res.socket ?? null;
this.headers = res.headers ? (0, _utils.fromNodeOutgoingHttpHeaders)(res.headers) : new Headers();
this.headPromise = new Promise((resolve)=>{
this.headPromiseResolve = resolve;
});
// Attach listeners for the `finish`, `end`, and `error` events to the
// `MockedResponse` instance.
this.hasStreamed = new Promise((resolve, reject)=>{
this.on('finish', ()=>resolve(true));
this.on('end', ()=>resolve(true));
this.on('error', (err)=>reject(err));
}).then((val)=>{
this.headPromiseResolve == null ? void 0 : this.headPromiseResolve.call(this);
return val;
});
if (res.resWriter) {
this.resWriter = res.resWriter;
}
}
appendHeader(name, value) {
const values = Array.isArray(value) ? value : [
value
];
for (const v of values){
this.headers.append(name, v);
}
return this;
}
/**
* Returns true if the response has been sent, false otherwise.
*
* @internal - used internally by Next.js
*/ get isSent() {
return this.finished || this.headersSent;
}
/**
* The `connection` property is just an alias for the `socket` property.
*
* @deprecated — since v13.0.0 - Use socket instead.
*/ get connection() {
return this.socket;
}
write(chunk) {
if (this.resWriter) {
return this.resWriter(chunk);
}
this.buffers.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
return true;
}
end() {
this.finished = true;
return super.end(...arguments);
}
/**
* This method is a no-op because the `MockedResponse` instance is not
* actually connected to a socket. This method is not specified on the
* interface type for `ServerResponse` but is called by Node.js.
*
* @see https://github.com/nodejs/node/pull/7949
*/ _implicitHeader() {}
_write(chunk, _encoding, callback) {
this.write(chunk);
// According to Node.js documentation, the callback MUST be invoked to
// signal that the write completed successfully. If this callback is not
// invoked, the 'finish' event will not be emitted.
//
// https://nodejs.org/docs/latest-v16.x/api/stream.html#writable_writechunk-encoding-callback
callback();
}
writeHead(statusCode, statusMessage, headers) {
if (!headers && typeof statusMessage !== 'string') {
headers = statusMessage;
} else if (typeof statusMessage === 'string' && statusMessage.length > 0) {
this.statusMessage = statusMessage;
}
if (headers) {
// When headers have been set with response.setHeader(), they will be
// merged with any headers passed to response.writeHead(), with the
// headers passed to response.writeHead() given precedence.
//
// https://nodejs.org/api/http.html#responsewriteheadstatuscode-statusmessage-headers
//
// For this reason, we need to only call `set` to ensure that this will
// overwrite any existing headers.
if (Array.isArray(headers)) {
// headers may be an Array where the keys and values are in the same list.
// It is not a list of tuples. So, the even-numbered offsets are key
// values, and the odd-numbered offsets are the associated values. The
// array is in the same format as request.rawHeaders.
for(let i = 0; i < headers.length; i += 2){
// The header key is always a string according to the spec.
this.setHeader(headers[i], headers[i + 1]);
}
} else {
for (const [key, value] of Object.entries(headers)){
// Skip undefined values
if (typeof value === 'undefined') continue;
this.setHeader(key, value);
}
}
}
this.statusCode = statusCode;
this.headersSent = true;
this.headPromiseResolve == null ? void 0 : this.headPromiseResolve.call(this);
return this;
}
hasHeader(name) {
return this.headers.has(name);
}
getHeader(name) {
return this.headers.get(name) ?? undefined;
}
getHeaders() {
return (0, _utils.toNodeOutgoingHttpHeaders)(this.headers);
}
getHeaderNames() {
return Array.from(this.headers.keys());
}
setHeader(name, value) {
if (Array.isArray(value)) {
// Because `set` here should override any existing values, we need to
// delete the existing values before setting the new ones via `append`.
this.headers.delete(name);
for (const v of value){
this.headers.append(name, v);
}
} else if (typeof value === 'number') {
this.headers.set(name, value.toString());
} else {
this.headers.set(name, value);
}
return this;
}
removeHeader(name) {
this.headers.delete(name);
}
flushHeaders() {
// This is a no-op because we don't actually have a socket to flush the
// headers to.
}
// The following methods are not implemented as they are not used in the
// Next.js codebase.
get strictContentLength() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
writeEarlyHints() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
get req() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
assignSocket() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
detachSocket() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
writeContinue() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
writeProcessing() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
get upgrading() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
get chunkedEncoding() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
get shouldKeepAlive() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
get useChunkedEncodingByDefault() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
get sendDate() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
setTimeout() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
addTrailers() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
setHeaders() {
throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
value: "E41",
enumerable: false,
configurable: true
});
}
}
function createRequestResponseMocks({ url, headers = {}, method = 'GET', bodyReadable, resWriter, socket = null }) {
return {
req: new MockedRequest({
url,
headers,
method,
socket,
readable: bodyReadable
}),
res: new MockedResponse({
socket,
resWriter
})
};
}
//# sourceMappingURL=mock-request.js.map