feat(blog): add file-based blog with dynamic slugs, MDX content and layout shell
- Introduced blog routing using Next.js App Router - Implemented dynamic [slug] pages for blog posts - Added MDX-based content loading via lib/posts - Integrated shared TopBar layout with navigation - Established clear content, lib and component separation
This commit is contained in:
PascalSchattenburg
195
apps/public-web/node_modules/next/dist/server/render-result.js
generated
vendored
Normal file
195
apps/public-web/node_modules/next/dist/server/render-result.js
generated
vendored
Normal file
@@ -0,0 +1,195 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return RenderResult;
|
||||
}
|
||||
});
|
||||
const _nodewebstreamshelper = require("./stream-utils/node-web-streams-helper");
|
||||
const _pipereadable = require("./pipe-readable");
|
||||
const _invarianterror = require("../shared/lib/invariant-error");
|
||||
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.InvariantError('dynamic responses cannot be unchunked. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
|
||||
value: "E732",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
return (0, _nodewebstreamshelper.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 (0, _nodewebstreamshelper.streamFromString)(this.response);
|
||||
}
|
||||
if (Buffer.isBuffer(this.response)) {
|
||||
return (0, _nodewebstreamshelper.streamFromBuffer)(this.response);
|
||||
}
|
||||
// If the response is an array of streams, then chain them together.
|
||||
if (Array.isArray(this.response)) {
|
||||
return (0, _nodewebstreamshelper.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 [
|
||||
(0, _nodewebstreamshelper.streamFromString)(this.response)
|
||||
];
|
||||
} else if (Array.isArray(this.response)) {
|
||||
return this.response;
|
||||
} else if (Buffer.isBuffer(this.response)) {
|
||||
return [
|
||||
(0, _nodewebstreamshelper.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 ((0, _pipereadable.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 (0, _pipereadable.pipeToNodeResponse)(this.readable, res, this.waitUntil);
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=render-result.js.map
|
||||
Reference in New Issue
Block a user