/opt/canhelp/node_modules/next/dist/esm/server
Edit: /opt/canhelp/node_modules/next/dist/esm/server/render-result.js (7204B)
import { chainStreams, streamFromBuffer, streamFromString, streamToString } from './stream-utils/node-web-streams-helper';
import { isAbortError, pipeToNodeResponse } from './pipe-readable';
import { InvariantError } from '../shared/lib/invariant-error';
export default class RenderResult {
static #_ = /**
* A render result that represents an empty response. This is used to
* represent a response that was not found or was already sent.
*/ this.EMPTY = new RenderResult(null, {
metadata: {},
contentType: null
});
/**
* Creates a new RenderResult instance from a static response.
*
* @param value the static response value
* @param contentType the content type of the response
* @returns a new RenderResult instance
*/ static fromStatic(value, contentType) {
return new RenderResult(value, {
metadata: {},
contentType
});
}
constructor(response, { contentType, waitUntil, metadata }){
this.response = response;
this.contentType = contentType;
this.metadata = metadata;
this.waitUntil = waitUntil;
}
assignMetadata(metadata) {
Object.assign(this.metadata, metadata);
}
/**
* Returns true if the response is null. It can be null if the response was
* not found or was already sent.
*/ get isNull() {
return this.response === null;
}
/**
* Returns false if the response is a string. It can be a string if the page
* was prerendered. If it's not, then it was generated dynamically.
*/ get isDynamic() {
return typeof this.response !== 'string';
}
toUnchunkedString(stream = false) {
if (this.response === null) {
// If the response is null, return an empty string. This behavior is
// intentional as we're now providing the `RenderResult.EMPTY` value.
return '';
}
if (typeof this.response !== 'string') {
if (!stream) {
throw Object.defineProperty(new InvariantError('dynamic responses cannot be unchunked. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
value: "E732",
enumerable: false,
configurable: true
});
}
return streamToString(this.readable);
}
return this.response;
}
/**
* Returns a readable stream of the response.
*/ get readable() {
if (this.response === null) {
// If the response is null, return an empty stream. This behavior is
// intentional as we're now providing the `RenderResult.EMPTY` value.
return new ReadableStream({
start (controller) {
controller.close();
}
});
}
if (typeof this.response === 'string') {
return streamFromString(this.response);
}
if (Buffer.isBuffer(this.response)) {
return streamFromBuffer(this.response);
}
// If the response is an array of streams, then chain them together.
if (Array.isArray(this.response)) {
return chainStreams(...this.response);
}
return this.response;
}
/**
* Coerces the response to an array of streams. This will convert the response
* to an array of streams if it is not already one.
*
* @returns An array of streams
*/ coerce() {
if (this.response === null) {
// If the response is null, return an empty stream. This behavior is
// intentional as we're now providing the `RenderResult.EMPTY` value.
return [];
}
if (typeof this.response === 'string') {
return [
streamFromString(this.response)
];
} else if (Array.isArray(this.response)) {
return this.response;
} else if (Buffer.isBuffer(this.response)) {
return [
streamFromBuffer(this.response)
];
} else {
return [
this.response
];
}
}
/**
* Unshifts a new stream to the response. This will convert the response to an
* array of streams if it is not already one and will add the new stream to
* the start of the array. When this response is piped, all of the streams
* will be piped one after the other.
*
* @param readable The new stream to unshift
*/ unshift(readable) {
// Coerce the response to an array of streams.
this.response = this.coerce();
// Add the new stream to the start of the array.
this.response.unshift(readable);
}
/**
* Chains a new stream to the response. This will convert the response to an
* array of streams if it is not already one and will add the new stream to
* the end. When this response is piped, all of the streams will be piped
* one after the other.
*
* @param readable The new stream to chain
*/ push(readable) {
// Coerce the response to an array of streams.
this.response = this.coerce();
// Add the new stream to the end of the array.
this.response.push(readable);
}
/**
* Pipes the response to a writable stream. This will close/cancel the
* writable stream if an error is encountered. If this doesn't throw, then
* the writable stream will be closed or aborted.
*
* @param writable Writable stream to pipe the response to
*/ async pipeTo(writable) {
try {
await this.readable.pipeTo(writable, {
// We want to close the writable stream ourselves so that we can wait
// for the waitUntil promise to resolve before closing it. If an error
// is encountered, we'll abort the writable stream if we swallowed the
// error.
preventClose: true
});
// If there is a waitUntil promise, wait for it to resolve before
// closing the writable stream.
if (this.waitUntil) await this.waitUntil;
// Close the writable stream.
await writable.close();
} catch (err) {
// If this is an abort error, we should abort the writable stream (as we
// took ownership of it when we started piping). We don't need to re-throw
// because we handled the error.
if (isAbortError(err)) {
// Abort the writable stream if an error is encountered.
await writable.abort(err);
return;
}
// We're not aborting the writer here as when this method throws it's not
// clear as to how so the caller should assume it's their responsibility
// to clean up the writer.
throw err;
}
}
/**
* Pipes the response to a node response. This will close/cancel the node
* response if an error is encountered.
*
* @param res
*/ async pipeToNodeResponse(res) {
await pipeToNodeResponse(this.readable, res, this.waitUntil);
}
}
//# sourceMappingURL=render-result.js.map