update wings
This commit is contained in:
@@ -1,51 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "PrerenderManifestMatcher", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return PrerenderManifestMatcher;
|
||||
}
|
||||
});
|
||||
const _routematcher = require("../../../../shared/lib/router/utils/route-matcher");
|
||||
const _routeregex = require("../../../../shared/lib/router/utils/route-regex");
|
||||
class PrerenderManifestMatcher {
|
||||
constructor(pathname, prerenderManifest){
|
||||
this.matchers = Object.entries(prerenderManifest.dynamicRoutes).filter(([source, route])=>{
|
||||
// If the pathname is a fallback source route, or the source route is
|
||||
// the same as the pathname, then we should include it in the matchers.
|
||||
return route.fallbackSourceRoute === pathname || source === pathname;
|
||||
}).map(([source, route])=>({
|
||||
source,
|
||||
route
|
||||
}));
|
||||
}
|
||||
/**
|
||||
* Match the pathname to the dynamic route. If no match is found, an error is
|
||||
* thrown.
|
||||
*
|
||||
* @param pathname - The pathname to match.
|
||||
* @returns The dynamic route that matches the pathname.
|
||||
*/ match(pathname) {
|
||||
// Iterate over the matchers. They're already in the correct order of
|
||||
// specificity as they were inserted into the prerender manifest that way
|
||||
// and iterating over them with Object.entries guarantees that.
|
||||
for (const matcher of this.matchers){
|
||||
// Lazily create the matcher, this is only done once per matcher.
|
||||
if (!matcher.matcher) {
|
||||
matcher.matcher = (0, _routematcher.getRouteMatcher)((0, _routeregex.getRouteRegex)(matcher.source));
|
||||
}
|
||||
const match = matcher.matcher(pathname);
|
||||
if (match) {
|
||||
return {
|
||||
source: matcher.source,
|
||||
route: matcher.route
|
||||
};
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=prerender-manifest-matcher.js.map
|
||||
36
build/node_modules/next/dist/server/route-modules/app-page/module.compiled.js
generated
vendored
36
build/node_modules/next/dist/server/route-modules/app-page/module.compiled.js
generated
vendored
@@ -1,36 +0,0 @@
|
||||
"use strict";
|
||||
if (process.env.NEXT_RUNTIME === 'edge') {
|
||||
module.exports = require('next/dist/server/route-modules/app-page/module.js');
|
||||
} else {
|
||||
if (process.env.__NEXT_EXPERIMENTAL_REACT) {
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
if (process.env.TURBOPACK) {
|
||||
module.exports = require('next/dist/compiled/next-server/app-page-turbo-experimental.runtime.dev.js');
|
||||
} else {
|
||||
module.exports = require('next/dist/compiled/next-server/app-page-experimental.runtime.dev.js');
|
||||
}
|
||||
} else {
|
||||
if (process.env.TURBOPACK) {
|
||||
module.exports = require('next/dist/compiled/next-server/app-page-turbo-experimental.runtime.prod.js');
|
||||
} else {
|
||||
module.exports = require('next/dist/compiled/next-server/app-page-experimental.runtime.prod.js');
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
if (process.env.TURBOPACK) {
|
||||
module.exports = require('next/dist/compiled/next-server/app-page-turbo.runtime.dev.js');
|
||||
} else {
|
||||
module.exports = require('next/dist/compiled/next-server/app-page.runtime.dev.js');
|
||||
}
|
||||
} else {
|
||||
if (process.env.TURBOPACK) {
|
||||
module.exports = require('next/dist/compiled/next-server/app-page-turbo.runtime.prod.js');
|
||||
} else {
|
||||
module.exports = require('next/dist/compiled/next-server/app-page.runtime.prod.js');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=module.compiled.js.map
|
||||
162
build/node_modules/next/dist/server/route-modules/app-page/module.js
generated
vendored
162
build/node_modules/next/dist/server/route-modules/app-page/module.js
generated
vendored
@@ -1,162 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
AppPageRouteModule: null,
|
||||
default: null,
|
||||
renderToHTMLOrFlight: null,
|
||||
vendored: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
AppPageRouteModule: function() {
|
||||
return AppPageRouteModule;
|
||||
},
|
||||
default: function() {
|
||||
return _default;
|
||||
},
|
||||
renderToHTMLOrFlight: function() {
|
||||
return _apprender.renderToHTMLOrFlight;
|
||||
},
|
||||
vendored: function() {
|
||||
return vendored;
|
||||
}
|
||||
});
|
||||
const _requestmeta = require("../../request-meta");
|
||||
const _apprender = require("../../app-render/app-render");
|
||||
const _routemodule = require("../route-module");
|
||||
const _entrypoints = /*#__PURE__*/ _interop_require_wildcard(require("./vendored/contexts/entrypoints"));
|
||||
const _prerendermanifestmatcher = require("./helpers/prerender-manifest-matcher");
|
||||
const _approuterheaders = require("../../../client/components/app-router-headers");
|
||||
const _interceptionroutes = require("../../../shared/lib/router/utils/interception-routes");
|
||||
const _rsc = require("../../normalizers/request/rsc");
|
||||
const _segmentprefixrsc = require("../../normalizers/request/segment-prefix-rsc");
|
||||
const _normalizerequesturl = require("./normalize-request-url");
|
||||
function _getRequireWildcardCache(nodeInterop) {
|
||||
if (typeof WeakMap !== "function") return null;
|
||||
var cacheBabelInterop = new WeakMap();
|
||||
var cacheNodeInterop = new WeakMap();
|
||||
return (_getRequireWildcardCache = function(nodeInterop) {
|
||||
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
|
||||
})(nodeInterop);
|
||||
}
|
||||
function _interop_require_wildcard(obj, nodeInterop) {
|
||||
if (!nodeInterop && obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
|
||||
return {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
var cache = _getRequireWildcardCache(nodeInterop);
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {
|
||||
__proto__: null
|
||||
};
|
||||
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for(var key in obj){
|
||||
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
let vendoredReactRSC;
|
||||
let vendoredReactSSR;
|
||||
// the vendored Reacts are loaded from their original source in the edge runtime
|
||||
if (process.env.NEXT_RUNTIME !== 'edge') {
|
||||
vendoredReactRSC = require('./vendored/rsc/entrypoints');
|
||||
vendoredReactSSR = require('./vendored/ssr/entrypoints');
|
||||
// In Node environments we need to access the correct React instance from external modules such
|
||||
// as global patches. We register the loaded React instances here.
|
||||
const { registerServerReact, registerClientReact } = require('../../runtime-reacts.external');
|
||||
registerServerReact(vendoredReactRSC.React);
|
||||
registerClientReact(vendoredReactSSR.React);
|
||||
}
|
||||
class AppPageRouteModule extends _routemodule.RouteModule {
|
||||
match(pathname, prerenderManifest) {
|
||||
// Lazily create the matcher based on the provided prerender manifest.
|
||||
let matcher = this.matchers.get(prerenderManifest);
|
||||
if (!matcher) {
|
||||
matcher = new _prerendermanifestmatcher.PrerenderManifestMatcher(this.definition.pathname, prerenderManifest);
|
||||
this.matchers.set(prerenderManifest, matcher);
|
||||
}
|
||||
// Match the pathname to the dynamic route.
|
||||
return matcher.match(pathname);
|
||||
}
|
||||
normalizeUrl(req, parsedUrl) {
|
||||
if (this.normalizers.segmentPrefetchRSC.match(parsedUrl.pathname || '/')) {
|
||||
const result = this.normalizers.segmentPrefetchRSC.extract(parsedUrl.pathname || '/');
|
||||
if (!result) return false;
|
||||
const { originalPathname, segmentPath } = result;
|
||||
parsedUrl.pathname = originalPathname;
|
||||
// Mark the request as a router prefetch request.
|
||||
req.headers[_approuterheaders.RSC_HEADER] = '1';
|
||||
req.headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] = '1';
|
||||
req.headers[_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER] = segmentPath;
|
||||
(0, _requestmeta.addRequestMeta)(req, 'isRSCRequest', true);
|
||||
(0, _requestmeta.addRequestMeta)(req, 'isPrefetchRSCRequest', true);
|
||||
(0, _requestmeta.addRequestMeta)(req, 'segmentPrefetchRSCRequest', segmentPath);
|
||||
} else if (this.normalizers.rsc.match(parsedUrl.pathname || '/')) {
|
||||
parsedUrl.pathname = this.normalizers.rsc.normalize(parsedUrl.pathname || '/', true);
|
||||
// Mark the request as a RSC request.
|
||||
req.headers[_approuterheaders.RSC_HEADER] = '1';
|
||||
(0, _requestmeta.addRequestMeta)(req, 'isRSCRequest', true);
|
||||
} else {
|
||||
super.normalizeUrl(req, parsedUrl);
|
||||
}
|
||||
(0, _normalizerequesturl.normalizeAppPageRequestUrl)(req, parsedUrl.pathname || '/');
|
||||
}
|
||||
render(req, res, context) {
|
||||
return (0, _apprender.renderToHTMLOrFlight)(req, res, context.page, context.query, context.fallbackRouteParams, context.renderOpts, context.serverComponentsHmrCache, context.sharedContext);
|
||||
}
|
||||
pathCouldBeIntercepted(resolvedPathname, interceptionRoutePatterns) {
|
||||
return (0, _interceptionroutes.isInterceptionRouteAppPath)(resolvedPathname) || interceptionRoutePatterns.some((regexp)=>{
|
||||
return regexp.test(resolvedPathname);
|
||||
});
|
||||
}
|
||||
getVaryHeader(resolvedPathname, interceptionRoutePatterns) {
|
||||
const baseVaryHeader = `${_approuterheaders.RSC_HEADER}, ${_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER}, ${_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER}, ${_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER}`;
|
||||
if (this.pathCouldBeIntercepted(resolvedPathname, interceptionRoutePatterns)) {
|
||||
// Interception route responses can vary based on the `Next-URL` header.
|
||||
// We use the Vary header to signal this behavior to the client to properly cache the response.
|
||||
return `${baseVaryHeader}, ${_approuterheaders.NEXT_URL}`;
|
||||
} else {
|
||||
// We don't need to include `Next-URL` in the Vary header for non-interception routes since it won't affect the response.
|
||||
// We also set this header for pages to avoid caching issues when navigating between pages and app.
|
||||
return baseVaryHeader;
|
||||
}
|
||||
}
|
||||
constructor(...args){
|
||||
super(...args), this.matchers = new WeakMap(), this.normalizers = {
|
||||
rsc: new _rsc.RSCPathnameNormalizer(),
|
||||
segmentPrefetchRSC: new _segmentprefixrsc.SegmentPrefixRSCPathnameNormalizer()
|
||||
};
|
||||
}
|
||||
}
|
||||
const vendored = {
|
||||
'react-rsc': vendoredReactRSC,
|
||||
'react-ssr': vendoredReactSSR,
|
||||
contexts: _entrypoints
|
||||
};
|
||||
const _default = AppPageRouteModule;
|
||||
|
||||
//# sourceMappingURL=module.js.map
|
||||
24
build/node_modules/next/dist/server/route-modules/app-page/module.render.js
generated
vendored
24
build/node_modules/next/dist/server/route-modules/app-page/module.render.js
generated
vendored
@@ -1,24 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "lazyRenderAppPage", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return lazyRenderAppPage;
|
||||
}
|
||||
});
|
||||
const lazyRenderAppPage = (...args)=>{
|
||||
if (process.env.NEXT_MINIMAL) {
|
||||
throw Object.defineProperty(new Error("Can't use lazyRenderAppPage in minimal mode"), "__NEXT_ERROR_CODE", {
|
||||
value: "E256",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
} else {
|
||||
const render = require('./module.compiled').renderToHTMLOrFlight;
|
||||
return render(...args);
|
||||
}
|
||||
};
|
||||
|
||||
//# sourceMappingURL=module.render.js.map
|
||||
25
build/node_modules/next/dist/server/route-modules/app-page/normalize-request-url.js
generated
vendored
25
build/node_modules/next/dist/server/route-modules/app-page/normalize-request-url.js
generated
vendored
@@ -1,25 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "normalizeAppPageRequestUrl", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return normalizeAppPageRequestUrl;
|
||||
}
|
||||
});
|
||||
const _url = require("../../../lib/url");
|
||||
const _formaturl = require("../../../shared/lib/router/utils/format-url");
|
||||
function normalizeAppPageRequestUrl(req, pathname) {
|
||||
if (!req.url) {
|
||||
return;
|
||||
}
|
||||
const normalizedUrl = (0, _url.parseReqUrl)(req.url);
|
||||
if (!normalizedUrl) {
|
||||
return;
|
||||
}
|
||||
normalizedUrl.pathname = pathname;
|
||||
req.url = (0, _formaturl.formatUrl)(normalizedUrl);
|
||||
}
|
||||
|
||||
//# sourceMappingURL=normalize-request-url.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].AppRouterContext;
|
||||
|
||||
//# sourceMappingURL=app-router-context.js.map
|
||||
@@ -1,87 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
AppRouterContext: null,
|
||||
HeadManagerContext: null,
|
||||
HooksClientContext: null,
|
||||
ImageConfigContext: null,
|
||||
RouterContext: null,
|
||||
ServerInsertedHtml: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
AppRouterContext: function() {
|
||||
return _approutercontextsharedruntime;
|
||||
},
|
||||
HeadManagerContext: function() {
|
||||
return _headmanagercontextsharedruntime;
|
||||
},
|
||||
HooksClientContext: function() {
|
||||
return _hooksclientcontextsharedruntime;
|
||||
},
|
||||
ImageConfigContext: function() {
|
||||
return _imageconfigcontextsharedruntime;
|
||||
},
|
||||
RouterContext: function() {
|
||||
return _routercontextsharedruntime;
|
||||
},
|
||||
ServerInsertedHtml: function() {
|
||||
return _serverinsertedhtmlsharedruntime;
|
||||
}
|
||||
});
|
||||
const _headmanagercontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/head-manager-context.shared-runtime"));
|
||||
const _serverinsertedhtmlsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/server-inserted-html.shared-runtime"));
|
||||
const _approutercontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/app-router-context.shared-runtime"));
|
||||
const _hooksclientcontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/hooks-client-context.shared-runtime"));
|
||||
const _routercontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/router-context.shared-runtime"));
|
||||
const _imageconfigcontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/image-config-context.shared-runtime"));
|
||||
function _getRequireWildcardCache(nodeInterop) {
|
||||
if (typeof WeakMap !== "function") return null;
|
||||
var cacheBabelInterop = new WeakMap();
|
||||
var cacheNodeInterop = new WeakMap();
|
||||
return (_getRequireWildcardCache = function(nodeInterop) {
|
||||
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
|
||||
})(nodeInterop);
|
||||
}
|
||||
function _interop_require_wildcard(obj, nodeInterop) {
|
||||
if (!nodeInterop && obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
|
||||
return {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
var cache = _getRequireWildcardCache(nodeInterop);
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {
|
||||
__proto__: null
|
||||
};
|
||||
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for(var key in obj){
|
||||
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=entrypoints.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].HeadManagerContext;
|
||||
|
||||
//# sourceMappingURL=head-manager-context.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].HooksClientContext;
|
||||
|
||||
//# sourceMappingURL=hooks-client-context.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].ImageConfigContext;
|
||||
|
||||
//# sourceMappingURL=image-config-context.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].RouterContext;
|
||||
|
||||
//# sourceMappingURL=router-context.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].ServerInsertedHtml;
|
||||
|
||||
//# sourceMappingURL=server-inserted-html.js.map
|
||||
140
build/node_modules/next/dist/server/route-modules/app-page/vendored/rsc/entrypoints.js
generated
vendored
140
build/node_modules/next/dist/server/route-modules/app-page/vendored/rsc/entrypoints.js
generated
vendored
@@ -1,140 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
React: null,
|
||||
ReactCompilerRuntime: null,
|
||||
ReactDOM: null,
|
||||
ReactJsxDevRuntime: null,
|
||||
ReactJsxRuntime: null,
|
||||
ReactServerDOMTurbopackServer: null,
|
||||
ReactServerDOMTurbopackStatic: null,
|
||||
ReactServerDOMWebpackServer: null,
|
||||
ReactServerDOMWebpackStatic: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
React: function() {
|
||||
return _react;
|
||||
},
|
||||
ReactCompilerRuntime: function() {
|
||||
return _compilerruntime;
|
||||
},
|
||||
ReactDOM: function() {
|
||||
return _reactdom;
|
||||
},
|
||||
ReactJsxDevRuntime: function() {
|
||||
return _jsxdevruntime;
|
||||
},
|
||||
ReactJsxRuntime: function() {
|
||||
return _jsxruntime;
|
||||
},
|
||||
ReactServerDOMTurbopackServer: function() {
|
||||
return ReactServerDOMTurbopackServer;
|
||||
},
|
||||
ReactServerDOMTurbopackStatic: function() {
|
||||
return ReactServerDOMTurbopackStatic;
|
||||
},
|
||||
ReactServerDOMWebpackServer: function() {
|
||||
return ReactServerDOMWebpackServer;
|
||||
},
|
||||
ReactServerDOMWebpackStatic: function() {
|
||||
return ReactServerDOMWebpackStatic;
|
||||
}
|
||||
});
|
||||
const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
|
||||
const _reactdom = /*#__PURE__*/ _interop_require_wildcard(require("react-dom"));
|
||||
const _jsxdevruntime = /*#__PURE__*/ _interop_require_wildcard(require("react/jsx-dev-runtime"));
|
||||
const _jsxruntime = /*#__PURE__*/ _interop_require_wildcard(require("react/jsx-runtime"));
|
||||
const _compilerruntime = /*#__PURE__*/ _interop_require_wildcard(require("react/compiler-runtime"));
|
||||
function _getRequireWildcardCache(nodeInterop) {
|
||||
if (typeof WeakMap !== "function") return null;
|
||||
var cacheBabelInterop = new WeakMap();
|
||||
var cacheNodeInterop = new WeakMap();
|
||||
return (_getRequireWildcardCache = function(nodeInterop) {
|
||||
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
|
||||
})(nodeInterop);
|
||||
}
|
||||
function _interop_require_wildcard(obj, nodeInterop) {
|
||||
if (!nodeInterop && obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
|
||||
return {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
var cache = _getRequireWildcardCache(nodeInterop);
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {
|
||||
__proto__: null
|
||||
};
|
||||
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for(var key in obj){
|
||||
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
function getAltProxyForBindingsDEV(type, pkg) {
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
const altType = type === 'Turbopack' ? 'Webpack' : 'Turbopack';
|
||||
const altPkg = pkg.replace(new RegExp(type, 'gi'), altType.toLowerCase());
|
||||
return new Proxy({}, {
|
||||
get (_, prop) {
|
||||
throw Object.defineProperty(new Error(`Expected to use ${type} bindings (${pkg}) for React but the current process is referencing '${prop}' from the ${altType} bindings (${altPkg}). This is likely a bug in our integration of the Next.js server runtime.`), "__NEXT_ERROR_CODE", {
|
||||
value: "E253",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
let ReactServerDOMTurbopackServer, ReactServerDOMWebpackServer;
|
||||
let ReactServerDOMTurbopackStatic, ReactServerDOMWebpackStatic;
|
||||
if (process.env.TURBOPACK) {
|
||||
ReactServerDOMTurbopackServer = // @ts-expect-error -- TODO: Add types
|
||||
// eslint-disable-next-line import/no-extraneous-dependencies
|
||||
require('react-server-dom-turbopack/server');
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
ReactServerDOMWebpackServer = getAltProxyForBindingsDEV('Turbopack', 'react-server-dom-turbopack/server');
|
||||
}
|
||||
ReactServerDOMTurbopackStatic = // @ts-expect-error -- TODO: Add types
|
||||
// eslint-disable-next-line import/no-extraneous-dependencies
|
||||
require('react-server-dom-turbopack/static');
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
ReactServerDOMWebpackStatic = getAltProxyForBindingsDEV('Turbopack', 'react-server-dom-turbopack/static');
|
||||
}
|
||||
} else {
|
||||
ReactServerDOMWebpackServer = // eslint-disable-next-line import/no-extraneous-dependencies
|
||||
require('react-server-dom-webpack/server');
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
ReactServerDOMTurbopackServer = getAltProxyForBindingsDEV('Webpack', 'react-server-dom-webpack/server');
|
||||
}
|
||||
ReactServerDOMWebpackStatic = // eslint-disable-next-line import/no-extraneous-dependencies
|
||||
require('react-server-dom-webpack/static');
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
ReactServerDOMTurbopackStatic = getAltProxyForBindingsDEV('Webpack', 'react-server-dom-webpack/static');
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=entrypoints.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-rsc'].ReactCompilerRuntime;
|
||||
|
||||
//# sourceMappingURL=react-compiler-runtime.js.map
|
||||
4
build/node_modules/next/dist/server/route-modules/app-page/vendored/rsc/react-dom.js
generated
vendored
4
build/node_modules/next/dist/server/route-modules/app-page/vendored/rsc/react-dom.js
generated
vendored
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-rsc'].ReactDOM;
|
||||
|
||||
//# sourceMappingURL=react-dom.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-rsc'].ReactJsxDevRuntime;
|
||||
|
||||
//# sourceMappingURL=react-jsx-dev-runtime.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-rsc'].ReactJsxRuntime;
|
||||
|
||||
//# sourceMappingURL=react-jsx-runtime.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-rsc'].ReactServerDOMTurbopackServer;
|
||||
|
||||
//# sourceMappingURL=react-server-dom-turbopack-server.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-rsc'].ReactServerDOMTurbopackStatic;
|
||||
|
||||
//# sourceMappingURL=react-server-dom-turbopack-static.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-rsc'].ReactServerDOMWebpackServer;
|
||||
|
||||
//# sourceMappingURL=react-server-dom-webpack-server.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-rsc'].ReactServerDOMWebpackStatic;
|
||||
|
||||
//# sourceMappingURL=react-server-dom-webpack-static.js.map
|
||||
4
build/node_modules/next/dist/server/route-modules/app-page/vendored/rsc/react.js
generated
vendored
4
build/node_modules/next/dist/server/route-modules/app-page/vendored/rsc/react.js
generated
vendored
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-rsc'].React;
|
||||
|
||||
//# sourceMappingURL=react.js.map
|
||||
125
build/node_modules/next/dist/server/route-modules/app-page/vendored/ssr/entrypoints.js
generated
vendored
125
build/node_modules/next/dist/server/route-modules/app-page/vendored/ssr/entrypoints.js
generated
vendored
@@ -1,125 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
React: null,
|
||||
ReactCompilerRuntime: null,
|
||||
ReactDOM: null,
|
||||
ReactDOMServer: null,
|
||||
ReactJsxDevRuntime: null,
|
||||
ReactJsxRuntime: null,
|
||||
ReactServerDOMTurbopackClient: null,
|
||||
ReactServerDOMWebpackClient: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
React: function() {
|
||||
return _react;
|
||||
},
|
||||
ReactCompilerRuntime: function() {
|
||||
return _compilerruntime;
|
||||
},
|
||||
ReactDOM: function() {
|
||||
return _reactdom;
|
||||
},
|
||||
ReactDOMServer: function() {
|
||||
return _server;
|
||||
},
|
||||
ReactJsxDevRuntime: function() {
|
||||
return _jsxdevruntime;
|
||||
},
|
||||
ReactJsxRuntime: function() {
|
||||
return _jsxruntime;
|
||||
},
|
||||
ReactServerDOMTurbopackClient: function() {
|
||||
return ReactServerDOMTurbopackClient;
|
||||
},
|
||||
ReactServerDOMWebpackClient: function() {
|
||||
return ReactServerDOMWebpackClient;
|
||||
}
|
||||
});
|
||||
const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
|
||||
const _reactdom = /*#__PURE__*/ _interop_require_wildcard(require("react-dom"));
|
||||
const _jsxdevruntime = /*#__PURE__*/ _interop_require_wildcard(require("react/jsx-dev-runtime"));
|
||||
const _jsxruntime = /*#__PURE__*/ _interop_require_wildcard(require("react/jsx-runtime"));
|
||||
const _compilerruntime = /*#__PURE__*/ _interop_require_wildcard(require("react/compiler-runtime"));
|
||||
const _server = /*#__PURE__*/ _interop_require_wildcard(require("react-dom/server"));
|
||||
function _getRequireWildcardCache(nodeInterop) {
|
||||
if (typeof WeakMap !== "function") return null;
|
||||
var cacheBabelInterop = new WeakMap();
|
||||
var cacheNodeInterop = new WeakMap();
|
||||
return (_getRequireWildcardCache = function(nodeInterop) {
|
||||
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
|
||||
})(nodeInterop);
|
||||
}
|
||||
function _interop_require_wildcard(obj, nodeInterop) {
|
||||
if (!nodeInterop && obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
|
||||
return {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
var cache = _getRequireWildcardCache(nodeInterop);
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {
|
||||
__proto__: null
|
||||
};
|
||||
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for(var key in obj){
|
||||
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
function getAltProxyForBindingsDEV(type, pkg) {
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
const altType = type === 'Turbopack' ? 'Webpack' : 'Turbopack';
|
||||
const altPkg = pkg.replace(new RegExp(type, 'gi'), altType.toLowerCase());
|
||||
return new Proxy({}, {
|
||||
get (_, prop) {
|
||||
throw Object.defineProperty(new Error(`Expected to use ${type} bindings (${pkg}) for React but the current process is referencing '${prop}' from the ${altType} bindings (${altPkg}). This is likely a bug in our integration of the Next.js server runtime.`), "__NEXT_ERROR_CODE", {
|
||||
value: "E253",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
let ReactServerDOMTurbopackClient, ReactServerDOMWebpackClient;
|
||||
if (process.env.TURBOPACK) {
|
||||
ReactServerDOMTurbopackClient = // @ts-expect-error -- TODO: Add types
|
||||
// eslint-disable-next-line import/no-extraneous-dependencies
|
||||
require('react-server-dom-turbopack/client');
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
ReactServerDOMWebpackClient = getAltProxyForBindingsDEV('Turbopack', 'react-server-dom-turbopack/client');
|
||||
}
|
||||
} else {
|
||||
ReactServerDOMWebpackClient = // eslint-disable-next-line import/no-extraneous-dependencies
|
||||
require('react-server-dom-webpack/client');
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
ReactServerDOMTurbopackClient = getAltProxyForBindingsDEV('Webpack', 'react-server-dom-webpack/client');
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=entrypoints.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-ssr'].ReactCompilerRuntime;
|
||||
|
||||
//# sourceMappingURL=react-compiler-runtime.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-ssr'].ReactDOMServer;
|
||||
|
||||
//# sourceMappingURL=react-dom-server.js.map
|
||||
4
build/node_modules/next/dist/server/route-modules/app-page/vendored/ssr/react-dom.js
generated
vendored
4
build/node_modules/next/dist/server/route-modules/app-page/vendored/ssr/react-dom.js
generated
vendored
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-ssr'].ReactDOM;
|
||||
|
||||
//# sourceMappingURL=react-dom.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-ssr'].ReactJsxDevRuntime;
|
||||
|
||||
//# sourceMappingURL=react-jsx-dev-runtime.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-ssr'].ReactJsxRuntime;
|
||||
|
||||
//# sourceMappingURL=react-jsx-runtime.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-ssr'].ReactServerDOMTurbopackClient;
|
||||
|
||||
//# sourceMappingURL=react-server-dom-turbopack-client.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-ssr'].ReactServerDOMWebpackClient;
|
||||
|
||||
//# sourceMappingURL=react-server-dom-webpack-client.js.map
|
||||
4
build/node_modules/next/dist/server/route-modules/app-page/vendored/ssr/react.js
generated
vendored
4
build/node_modules/next/dist/server/route-modules/app-page/vendored/ssr/react.js
generated
vendored
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['react-ssr'].React;
|
||||
|
||||
//# sourceMappingURL=react.js.map
|
||||
@@ -1,85 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "autoImplementMethods", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return autoImplementMethods;
|
||||
}
|
||||
});
|
||||
const _http = require("../../../web/http");
|
||||
const AUTOMATIC_ROUTE_METHODS = [
|
||||
'HEAD',
|
||||
'OPTIONS'
|
||||
];
|
||||
function handleMethodNotAllowedResponse() {
|
||||
return new Response(null, {
|
||||
status: 405
|
||||
});
|
||||
}
|
||||
function autoImplementMethods(handlers) {
|
||||
// Loop through all the HTTP methods to create the initial methods object.
|
||||
// Each of the methods will be set to the 405 response handler.
|
||||
const methods = _http.HTTP_METHODS.reduce((acc, method)=>({
|
||||
...acc,
|
||||
// If the userland module implements the method, then use it. Otherwise,
|
||||
// use the 405 response handler.
|
||||
[method]: handlers[method] ?? handleMethodNotAllowedResponse
|
||||
}), {});
|
||||
// Get all the methods that could be automatically implemented that were not
|
||||
// implemented by the userland module.
|
||||
const implemented = new Set(_http.HTTP_METHODS.filter((method)=>handlers[method]));
|
||||
const missing = AUTOMATIC_ROUTE_METHODS.filter((method)=>!implemented.has(method));
|
||||
// Loop over the missing methods to automatically implement them if we can.
|
||||
for (const method of missing){
|
||||
// If the userland module doesn't implement the HEAD method, then
|
||||
// we'll automatically implement it by calling the GET method (if it
|
||||
// exists).
|
||||
if (method === 'HEAD') {
|
||||
if (handlers.GET) {
|
||||
// Implement the HEAD method by calling the GET method.
|
||||
methods.HEAD = handlers.GET;
|
||||
// Mark it as implemented.
|
||||
implemented.add('HEAD');
|
||||
}
|
||||
continue;
|
||||
}
|
||||
// If OPTIONS is not provided then implement it.
|
||||
if (method === 'OPTIONS') {
|
||||
// TODO: check if HEAD is implemented, if so, use it to add more headers
|
||||
// Get all the methods that were implemented by the userland module.
|
||||
const allow = [
|
||||
'OPTIONS',
|
||||
...implemented
|
||||
];
|
||||
// If the list of methods doesn't include HEAD, but it includes GET, then
|
||||
// add HEAD as it's automatically implemented.
|
||||
if (!implemented.has('HEAD') && implemented.has('GET')) {
|
||||
allow.push('HEAD');
|
||||
}
|
||||
// Sort and join the list with commas to create the `Allow` header. See:
|
||||
// https://httpwg.org/specs/rfc9110.html#field.allow
|
||||
const headers = {
|
||||
Allow: allow.sort().join(', ')
|
||||
};
|
||||
// Implement the OPTIONS method by returning a 204 response with the
|
||||
// `Allow` header.
|
||||
methods.OPTIONS = ()=>new Response(null, {
|
||||
status: 204,
|
||||
headers
|
||||
});
|
||||
// Mark this method as implemented.
|
||||
implemented.add('OPTIONS');
|
||||
continue;
|
||||
}
|
||||
throw Object.defineProperty(new Error(`Invariant: should handle all automatic implementable methods, got method: ${method}`), "__NEXT_ERROR_CODE", {
|
||||
value: "E211",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
return methods;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=auto-implement-methods.js.map
|
||||
24
build/node_modules/next/dist/server/route-modules/app-route/helpers/clean-url.js
generated
vendored
24
build/node_modules/next/dist/server/route-modules/app-route/helpers/clean-url.js
generated
vendored
@@ -1,24 +0,0 @@
|
||||
/**
|
||||
* Cleans a URL by stripping the protocol, host, and search params.
|
||||
*
|
||||
* @param urlString the url to clean
|
||||
* @returns the cleaned url
|
||||
*/ "use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "cleanURL", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return cleanURL;
|
||||
}
|
||||
});
|
||||
function cleanURL(url) {
|
||||
const u = new URL(url);
|
||||
u.host = 'localhost:3000';
|
||||
u.search = '';
|
||||
u.protocol = 'http';
|
||||
return u;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=clean-url.js.map
|
||||
@@ -1,29 +0,0 @@
|
||||
/**
|
||||
* Get pathname from absolute path.
|
||||
*
|
||||
* @param absolutePath the absolute path
|
||||
* @returns the pathname
|
||||
*/ "use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "getPathnameFromAbsolutePath", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return getPathnameFromAbsolutePath;
|
||||
}
|
||||
});
|
||||
function getPathnameFromAbsolutePath(absolutePath) {
|
||||
// Remove prefix including app dir
|
||||
let appDir = '/app/';
|
||||
if (!absolutePath.includes(appDir)) {
|
||||
appDir = '\\app\\';
|
||||
}
|
||||
const [, ...parts] = absolutePath.split(appDir);
|
||||
const relativePath = appDir[0] + parts.join(appDir);
|
||||
// remove extension
|
||||
const pathname = relativePath.split('.').slice(0, -1).join('.');
|
||||
return pathname;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=get-pathname-from-absolute-path.js.map
|
||||
@@ -1,15 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "isStaticGenEnabled", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return isStaticGenEnabled;
|
||||
}
|
||||
});
|
||||
function isStaticGenEnabled(mod) {
|
||||
return mod.dynamic === 'force-static' || mod.dynamic === 'error' || mod.revalidate === false || mod.revalidate !== undefined && mod.revalidate > 0 || typeof mod.generateStaticParams == 'function';
|
||||
}
|
||||
|
||||
//# sourceMappingURL=is-static-gen-enabled.js.map
|
||||
@@ -1,20 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "parsedUrlQueryToParams", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return parsedUrlQueryToParams;
|
||||
}
|
||||
});
|
||||
function parsedUrlQueryToParams(query) {
|
||||
const params = {};
|
||||
for (const [key, value] of Object.entries(query)){
|
||||
if (typeof value === 'undefined') continue;
|
||||
params[key] = value;
|
||||
}
|
||||
return params;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=parsed-url-query-to-params.js.map
|
||||
36
build/node_modules/next/dist/server/route-modules/app-route/module.compiled.js
generated
vendored
36
build/node_modules/next/dist/server/route-modules/app-route/module.compiled.js
generated
vendored
@@ -1,36 +0,0 @@
|
||||
"use strict";
|
||||
if (process.env.NEXT_RUNTIME === 'edge') {
|
||||
module.exports = require('next/dist/server/route-modules/app-route/module.js');
|
||||
} else {
|
||||
if (process.env.__NEXT_EXPERIMENTAL_REACT) {
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
if (process.env.TURBOPACK) {
|
||||
module.exports = require('next/dist/compiled/next-server/app-route-turbo-experimental.runtime.dev.js');
|
||||
} else {
|
||||
module.exports = require('next/dist/compiled/next-server/app-route-experimental.runtime.dev.js');
|
||||
}
|
||||
} else {
|
||||
if (process.env.TURBOPACK) {
|
||||
module.exports = require('next/dist/compiled/next-server/app-route-turbo-experimental.runtime.prod.js');
|
||||
} else {
|
||||
module.exports = require('next/dist/compiled/next-server/app-route-experimental.runtime.prod.js');
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
if (process.env.TURBOPACK) {
|
||||
module.exports = require('next/dist/compiled/next-server/app-route-turbo.runtime.dev.js');
|
||||
} else {
|
||||
module.exports = require('next/dist/compiled/next-server/app-route.runtime.dev.js');
|
||||
}
|
||||
} else {
|
||||
if (process.env.TURBOPACK) {
|
||||
module.exports = require('next/dist/compiled/next-server/app-route-turbo.runtime.prod.js');
|
||||
} else {
|
||||
module.exports = require('next/dist/compiled/next-server/app-route.runtime.prod.js');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=module.compiled.js.map
|
||||
915
build/node_modules/next/dist/server/route-modules/app-route/module.js
generated
vendored
915
build/node_modules/next/dist/server/route-modules/app-route/module.js
generated
vendored
@@ -1,915 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
AppRouteRouteModule: null,
|
||||
WrappedNextRouterError: null,
|
||||
default: null,
|
||||
hasNonStaticMethods: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
AppRouteRouteModule: function() {
|
||||
return AppRouteRouteModule;
|
||||
},
|
||||
WrappedNextRouterError: function() {
|
||||
return WrappedNextRouterError;
|
||||
},
|
||||
default: function() {
|
||||
return _default;
|
||||
},
|
||||
hasNonStaticMethods: function() {
|
||||
return hasNonStaticMethods;
|
||||
}
|
||||
});
|
||||
const _routemodule = require("../route-module");
|
||||
const _requeststore = require("../../async-storage/request-store");
|
||||
const _workstore = require("../../async-storage/work-store");
|
||||
const _http = require("../../web/http");
|
||||
const _implicittags = require("../../lib/implicit-tags");
|
||||
const _patchfetch = require("../../lib/patch-fetch");
|
||||
const _tracer = require("../../lib/trace/tracer");
|
||||
const _constants = require("../../lib/trace/constants");
|
||||
const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../build/output/log"));
|
||||
const _autoimplementmethods = require("./helpers/auto-implement-methods");
|
||||
const _requestcookies = require("../../web/spec-extension/adapters/request-cookies");
|
||||
const _headers = require("../../web/spec-extension/adapters/headers");
|
||||
const _parsedurlquerytoparams = require("./helpers/parsed-url-query-to-params");
|
||||
const _prospectiverenderutils = require("../../app-render/prospective-render-utils");
|
||||
const _hooksservercontext = /*#__PURE__*/ _interop_require_wildcard(require("../../../client/components/hooks-server-context"));
|
||||
const _workasyncstorageexternal = require("../../app-render/work-async-storage.external");
|
||||
const _workunitasyncstorageexternal = require("../../app-render/work-unit-async-storage.external");
|
||||
const _actionasyncstorageexternal = require("../../app-render/action-async-storage.external");
|
||||
const _sharedmodules = /*#__PURE__*/ _interop_require_wildcard(require("./shared-modules"));
|
||||
const _serveractionrequestmeta = require("../../lib/server-action-request-meta");
|
||||
const _cookies = require("next/dist/compiled/@edge-runtime/cookies");
|
||||
const _cleanurl = require("./helpers/clean-url");
|
||||
const _staticgenerationbailout = require("../../../client/components/static-generation-bailout");
|
||||
const _isstaticgenenabled = require("./helpers/is-static-gen-enabled");
|
||||
const _dynamicrendering = require("../../app-render/dynamic-rendering");
|
||||
const _reflect = require("../../web/spec-extension/adapters/reflect");
|
||||
const _cachesignal = require("../../app-render/cache-signal");
|
||||
const _scheduler = require("../../../lib/scheduler");
|
||||
const _params = require("../../request/params");
|
||||
const _redirect = require("../../../client/components/redirect");
|
||||
const _redirecterror = require("../../../client/components/redirect-error");
|
||||
const _httpaccessfallback = require("../../../client/components/http-access-fallback/http-access-fallback");
|
||||
const _redirectstatuscode = require("../../../client/components/redirect-status-code");
|
||||
const _constants1 = require("../../../lib/constants");
|
||||
const _revalidationutils = require("../../revalidation-utils");
|
||||
const _trackmoduleloadingexternal = require("../../app-render/module-loading/track-module-loading.external");
|
||||
const _invarianterror = require("../../../shared/lib/invariant-error");
|
||||
const _resumedatacache = require("../../resume-data-cache/resume-data-cache");
|
||||
function _getRequireWildcardCache(nodeInterop) {
|
||||
if (typeof WeakMap !== "function") return null;
|
||||
var cacheBabelInterop = new WeakMap();
|
||||
var cacheNodeInterop = new WeakMap();
|
||||
return (_getRequireWildcardCache = function(nodeInterop) {
|
||||
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
|
||||
})(nodeInterop);
|
||||
}
|
||||
function _interop_require_wildcard(obj, nodeInterop) {
|
||||
if (!nodeInterop && obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
|
||||
return {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
var cache = _getRequireWildcardCache(nodeInterop);
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {
|
||||
__proto__: null
|
||||
};
|
||||
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for(var key in obj){
|
||||
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
class WrappedNextRouterError {
|
||||
constructor(error, headers){
|
||||
this.error = error;
|
||||
this.headers = headers;
|
||||
}
|
||||
}
|
||||
class AppRouteRouteModule extends _routemodule.RouteModule {
|
||||
static #_ = this.sharedModules = _sharedmodules;
|
||||
constructor({ userland, getUserland, definition, distDir, relativeProjectDir, resolvedPagePath, nextConfigOutput }){
|
||||
super({
|
||||
userland: userland,
|
||||
definition,
|
||||
distDir,
|
||||
relativeProjectDir
|
||||
}), /**
|
||||
* A reference to the request async storage.
|
||||
*/ this.workUnitAsyncStorage = _workunitasyncstorageexternal.workUnitAsyncStorage, /**
|
||||
* A reference to the static generation async storage.
|
||||
*/ this.workAsyncStorage = _workasyncstorageexternal.workAsyncStorage, /**
|
||||
* An interface to call server hooks which interact with the underlying
|
||||
* storage.
|
||||
*/ this.serverHooks = _hooksservercontext, /**
|
||||
* A reference to the mutation related async storage, such as mutations of
|
||||
* cookies.
|
||||
*/ this.actionAsyncStorage = _actionasyncstorageexternal.actionAsyncStorage;
|
||||
this.resolvedPagePath = resolvedPagePath;
|
||||
this.nextConfigOutput = nextConfigOutput;
|
||||
this._getUserland = getUserland;
|
||||
// Automatically implement some methods if they aren't implemented by the
|
||||
// userland module.
|
||||
this.methods = (0, _autoimplementmethods.autoImplementMethods)(userland);
|
||||
// Get the non-static methods for this route.
|
||||
this.hasNonStaticMethods = hasNonStaticMethods(userland);
|
||||
// Get the dynamic property from the userland module.
|
||||
this.dynamic = userland.dynamic;
|
||||
if (this.nextConfigOutput === 'export') {
|
||||
if (this.dynamic === 'force-dynamic') {
|
||||
throw Object.defineProperty(new Error(`export const dynamic = "force-dynamic" on page "${definition.pathname}" cannot be used with "output: export". See more info here: https://nextjs.org/docs/advanced-features/static-html-export`), "__NEXT_ERROR_CODE", {
|
||||
value: "E278",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
} else if (!(0, _isstaticgenenabled.isStaticGenEnabled)(this.userland) && this.userland['GET']) {
|
||||
throw Object.defineProperty(new Error(`export const dynamic = "force-static"/export const revalidate not configured on route "${definition.pathname}" with "output: export". See more info here: https://nextjs.org/docs/advanced-features/static-html-export`), "__NEXT_ERROR_CODE", {
|
||||
value: "E301",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
} else {
|
||||
this.dynamic = 'error';
|
||||
}
|
||||
}
|
||||
// We only warn in development after here, so return if we're not in
|
||||
// development.
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
// Print error in development if the exported handlers are in lowercase, only
|
||||
// uppercase handlers are supported.
|
||||
const lowercased = _http.HTTP_METHODS.map((method)=>method.toLowerCase());
|
||||
for (const method of lowercased){
|
||||
if (method in this.userland) {
|
||||
_log.error(`Detected lowercase method '${method}' in '${this.resolvedPagePath}'. Export the uppercase '${method.toUpperCase()}' method name to fix this error.`);
|
||||
}
|
||||
}
|
||||
// Print error if the module exports a default handler, they must use named
|
||||
// exports for each HTTP method.
|
||||
if ('default' in this.userland) {
|
||||
_log.error(`Detected default export in '${this.resolvedPagePath}'. Export a named export for each HTTP method instead.`);
|
||||
}
|
||||
// If there is no methods exported by this module, then return a not found
|
||||
// response.
|
||||
if (!_http.HTTP_METHODS.some((method)=>method in this.userland)) {
|
||||
_log.error(`No HTTP methods exported in '${this.resolvedPagePath}'. Export a named export for each HTTP method.`);
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Resolves the handler function for the given method.
|
||||
*
|
||||
* @param method the requested method
|
||||
* @returns the handler function for the given method
|
||||
*/ resolve(method) {
|
||||
// Ensure that the requested method is a valid method (to prevent RCE's).
|
||||
if (!(0, _http.isHTTPMethod)(method)) return ()=>new Response(null, {
|
||||
status: 400
|
||||
});
|
||||
return (0, _autoimplementmethods.autoImplementMethods)(this.userland)[method];
|
||||
}
|
||||
/**
|
||||
* Like resolve(), but re-fetches the userland module on every call via the
|
||||
* async getter. Only used in Turbopack dev mode, where server HMR disposes
|
||||
* modules between requests. The async wrapper also unwraps async-module
|
||||
* Promises produced by ESM-only serverExternalPackages.
|
||||
*/ async resolveWithGetter(method, getUserland) {
|
||||
if (!(0, _http.isHTTPMethod)(method)) return ()=>new Response(null, {
|
||||
status: 400
|
||||
});
|
||||
const userland = await getUserland();
|
||||
return (0, _autoimplementmethods.autoImplementMethods)(userland)[method];
|
||||
}
|
||||
async do(handler, actionStore, workStore, // @TODO refactor to not take this argument but instead construct the RequestStore
|
||||
// inside this function. Right now we get passed a RequestStore even when
|
||||
// we're going to do a prerender. We should probably just split do up into prexecute and execute
|
||||
requestStore, implicitTags, request, context) {
|
||||
const isStaticGeneration = workStore.isStaticGeneration;
|
||||
const cacheComponentsEnabled = !!context.renderOpts.cacheComponents;
|
||||
// Patch the global fetch.
|
||||
(0, _patchfetch.patchFetch)({
|
||||
workAsyncStorage: this.workAsyncStorage,
|
||||
workUnitAsyncStorage: this.workUnitAsyncStorage
|
||||
});
|
||||
const handlerContext = {
|
||||
params: context.params ? (0, _params.createServerParamsForRoute)((0, _parsedurlquerytoparams.parsedUrlQueryToParams)(context.params)) : undefined
|
||||
};
|
||||
const resolvePendingRevalidations = ()=>{
|
||||
const maybeRevalidatesPromise = (0, _revalidationutils.executeRevalidates)(workStore);
|
||||
if (maybeRevalidatesPromise !== false) {
|
||||
context.renderOpts.pendingWaitUntil = maybeRevalidatesPromise.finally(()=>{
|
||||
if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
|
||||
console.log('pending revalidates promise finished for:', requestStore.url.pathname + requestStore.url.search);
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
let prerenderStore = null;
|
||||
let res;
|
||||
try {
|
||||
if (isStaticGeneration) {
|
||||
const userlandRevalidate = this.userland.revalidate;
|
||||
const defaultRevalidate = // If the static generation store does not have a revalidate value
|
||||
// set, then we should set it the revalidate value from the userland
|
||||
// module or default to false.
|
||||
userlandRevalidate === false || userlandRevalidate === undefined ? _constants1.INFINITE_CACHE : userlandRevalidate;
|
||||
if (cacheComponentsEnabled) {
|
||||
/**
|
||||
* When we are attempting to statically prerender the GET handler of a route.ts module
|
||||
* and cacheComponents is on we follow a similar pattern to rendering.
|
||||
*
|
||||
* We first run the handler letting caches fill. If something synchronously dynamic occurs
|
||||
* during this prospective render then we can infer it will happen on every render and we
|
||||
* just bail out of prerendering.
|
||||
*
|
||||
* Next we run the handler again and we check if we get a result back in a microtask.
|
||||
* Next.js expects the return value to be a Response or a Thenable that resolves to a Response.
|
||||
* Unfortunately Response's do not allow for accessing the response body synchronously or in
|
||||
* a microtask so we need to allow one more task to unwrap the response body. This is a slightly
|
||||
* different semantic than what we have when we render and it means that certain tasks can still
|
||||
* execute before a prerender completes such as a carefully timed setImmediate.
|
||||
*
|
||||
* Functionally though IO should still take longer than the time it takes to unwrap the response body
|
||||
* so our heuristic of excluding any IO should be preserved.
|
||||
*/ const prospectiveController = new AbortController();
|
||||
let prospectiveRenderIsDynamic = false;
|
||||
const cacheSignal = new _cachesignal.CacheSignal();
|
||||
let dynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(undefined);
|
||||
// TODO: Route handlers are never resumed, so it's counter-intuitive
|
||||
// to use an RDC here. However, we need the data cache to store cached
|
||||
// results in memory during the prospective prerender, so that they
|
||||
// can be retrieved during the final prerender within microtasks. This
|
||||
// is crucial when doing revalidations of a deployed route handler,
|
||||
// where the default cache handler does not do any in-memory caching.
|
||||
// We should replace the `prerenderResumeDataCache` and
|
||||
// `renderResumeDataCache` with a single `dataCache` property that is
|
||||
// conceptually not tied to resuming, and also avoids the unnecessary
|
||||
// complexity of using a mutable and an immutable resume data cache.
|
||||
const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
|
||||
const prospectiveRoutePrerenderStore = prerenderStore = {
|
||||
type: 'prerender',
|
||||
phase: 'action',
|
||||
// This replicates prior behavior where rootParams is empty in routes
|
||||
// TODO we need to make this have the proper rootParams for this route
|
||||
rootParams: {},
|
||||
fallbackRouteParams: null,
|
||||
implicitTags,
|
||||
renderSignal: prospectiveController.signal,
|
||||
controller: prospectiveController,
|
||||
cacheSignal,
|
||||
// During prospective render we don't use a controller
|
||||
// because we need to let all caches fill.
|
||||
dynamicTracking,
|
||||
allowEmptyStaticShell: false,
|
||||
revalidate: defaultRevalidate,
|
||||
expire: _constants1.INFINITE_CACHE,
|
||||
stale: _constants1.INFINITE_CACHE,
|
||||
tags: [
|
||||
...implicitTags.tags
|
||||
],
|
||||
prerenderResumeDataCache,
|
||||
renderResumeDataCache: null,
|
||||
hmrRefreshHash: undefined,
|
||||
varyParamsAccumulator: null
|
||||
};
|
||||
let prospectiveResult;
|
||||
try {
|
||||
prospectiveResult = this.workUnitAsyncStorage.run(prospectiveRoutePrerenderStore, handler, request, handlerContext);
|
||||
} catch (err) {
|
||||
if (prospectiveController.signal.aborted) {
|
||||
// the route handler called an API which is always dynamic
|
||||
// there is no need to try again
|
||||
prospectiveRenderIsDynamic = true;
|
||||
} else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
|
||||
(0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
|
||||
}
|
||||
}
|
||||
if (typeof prospectiveResult === 'object' && prospectiveResult !== null && typeof prospectiveResult.then === 'function') {
|
||||
// The handler returned a Thenable. We'll listen for rejections to determine
|
||||
// if the route is erroring for dynamic reasons.
|
||||
;
|
||||
prospectiveResult.then(()=>{}, (err)=>{
|
||||
if (prospectiveController.signal.aborted) {
|
||||
// the route handler called an API which is always dynamic
|
||||
// there is no need to try again
|
||||
prospectiveRenderIsDynamic = true;
|
||||
} else if (process.env.NEXT_DEBUG_BUILD) {
|
||||
(0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
|
||||
}
|
||||
});
|
||||
}
|
||||
(0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
|
||||
await cacheSignal.cacheReady();
|
||||
if (prospectiveRenderIsDynamic) {
|
||||
// the route handler called an API which is always dynamic
|
||||
// there is no need to try again
|
||||
const dynamicReason = (0, _dynamicrendering.getFirstDynamicReason)(dynamicTracking);
|
||||
if (dynamicReason) {
|
||||
throw Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${workStore.route} couldn't be rendered statically because it used \`${dynamicReason}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
|
||||
value: "E558",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
} else {
|
||||
console.error('Expected Next.js to keep track of reason for opting out of static rendering but one was not found. This is a bug in Next.js');
|
||||
throw Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${workStore.route} couldn't be rendered statically because it used a dynamic API. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
|
||||
value: "E577",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
// TODO start passing this controller to the route handler. We should expose
|
||||
// it so the handler to abort inflight requests and other operations if we abort
|
||||
// the prerender.
|
||||
const finalController = new AbortController();
|
||||
dynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(undefined);
|
||||
const finalRoutePrerenderStore = prerenderStore = {
|
||||
type: 'prerender',
|
||||
phase: 'action',
|
||||
rootParams: {},
|
||||
fallbackRouteParams: null,
|
||||
implicitTags,
|
||||
renderSignal: finalController.signal,
|
||||
controller: finalController,
|
||||
cacheSignal: null,
|
||||
dynamicTracking,
|
||||
allowEmptyStaticShell: false,
|
||||
revalidate: defaultRevalidate,
|
||||
expire: _constants1.INFINITE_CACHE,
|
||||
stale: _constants1.INFINITE_CACHE,
|
||||
tags: [
|
||||
...implicitTags.tags
|
||||
],
|
||||
prerenderResumeDataCache,
|
||||
renderResumeDataCache: null,
|
||||
hmrRefreshHash: undefined,
|
||||
varyParamsAccumulator: null
|
||||
};
|
||||
let responseHandled = false;
|
||||
res = await new Promise((resolve, reject)=>{
|
||||
(0, _scheduler.scheduleImmediate)(async ()=>{
|
||||
try {
|
||||
const result = await this.workUnitAsyncStorage.run(finalRoutePrerenderStore, handler, request, handlerContext);
|
||||
if (responseHandled) {
|
||||
// we already rejected in the followup task
|
||||
return;
|
||||
} else if (!(result instanceof Response)) {
|
||||
// This is going to error but we let that happen below
|
||||
resolve(result);
|
||||
return;
|
||||
}
|
||||
responseHandled = true;
|
||||
let bodyHandled = false;
|
||||
result.arrayBuffer().then((body)=>{
|
||||
if (!bodyHandled) {
|
||||
bodyHandled = true;
|
||||
resolve(new Response(body, {
|
||||
headers: result.headers,
|
||||
status: result.status,
|
||||
statusText: result.statusText
|
||||
}));
|
||||
}
|
||||
}, reject);
|
||||
(0, _scheduler.scheduleImmediate)(()=>{
|
||||
if (!bodyHandled) {
|
||||
bodyHandled = true;
|
||||
finalController.abort();
|
||||
reject(createCacheComponentsError(workStore.route));
|
||||
}
|
||||
});
|
||||
} catch (err) {
|
||||
reject(err);
|
||||
}
|
||||
});
|
||||
(0, _scheduler.scheduleImmediate)(()=>{
|
||||
if (!responseHandled) {
|
||||
responseHandled = true;
|
||||
finalController.abort();
|
||||
reject(createCacheComponentsError(workStore.route));
|
||||
}
|
||||
});
|
||||
});
|
||||
if (finalController.signal.aborted) {
|
||||
// We aborted from within the execution
|
||||
throw createCacheComponentsError(workStore.route);
|
||||
} else {
|
||||
// We didn't abort during the execution. We can abort now as a matter of semantics
|
||||
// though at the moment nothing actually consumes this signal so it won't halt any
|
||||
// inflight work.
|
||||
finalController.abort();
|
||||
}
|
||||
} else {
|
||||
prerenderStore = {
|
||||
type: 'prerender-legacy',
|
||||
phase: 'action',
|
||||
rootParams: {},
|
||||
implicitTags,
|
||||
revalidate: defaultRevalidate,
|
||||
expire: _constants1.INFINITE_CACHE,
|
||||
stale: _constants1.INFINITE_CACHE,
|
||||
tags: [
|
||||
...implicitTags.tags
|
||||
]
|
||||
};
|
||||
res = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderStore, handler, request, handlerContext);
|
||||
}
|
||||
} else {
|
||||
res = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, handler, request, handlerContext);
|
||||
}
|
||||
} catch (err) {
|
||||
if ((0, _redirecterror.isRedirectError)(err)) {
|
||||
const url = (0, _redirect.getURLFromRedirectError)(err);
|
||||
if (!url) {
|
||||
throw Object.defineProperty(new Error('Invariant: Unexpected redirect url format'), "__NEXT_ERROR_CODE", {
|
||||
value: "E399",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
// We need to capture any headers that should be sent on
|
||||
// the response.
|
||||
const headers = new Headers({
|
||||
Location: url
|
||||
});
|
||||
// Let's append any cookies that were added by the
|
||||
// cookie API.
|
||||
// TODO leaving the gate here b/c it indicates that we might not actually want to do this
|
||||
// on every `do` call. During prerender there should be no mutableCookies because
|
||||
(0, _requestcookies.appendMutableCookies)(headers, requestStore.mutableCookies);
|
||||
resolvePendingRevalidations();
|
||||
// Return the redirect response.
|
||||
return new Response(null, {
|
||||
// If we're in an action, we want to use a 303 redirect as we don't
|
||||
// want the POST request to follow the redirect, as it could result in
|
||||
// erroneous re-submissions.
|
||||
status: actionStore.isAction ? _redirectstatuscode.RedirectStatusCode.SeeOther : (0, _redirect.getRedirectStatusCodeFromError)(err),
|
||||
headers
|
||||
});
|
||||
} else if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(err)) {
|
||||
const httpStatus = (0, _httpaccessfallback.getAccessFallbackHTTPStatus)(err);
|
||||
return new Response(null, {
|
||||
status: httpStatus
|
||||
});
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
// Validate that the response is a valid response object.
|
||||
if (!(res instanceof Response)) {
|
||||
var _res_constructor;
|
||||
const invalidType = res === null ? 'null' : res === undefined ? 'undefined' : typeof res === 'object' ? ((_res_constructor = res.constructor) == null ? void 0 : _res_constructor.name) || 'object' : typeof res;
|
||||
throw Object.defineProperty(new Error(`No response is returned from route handler '${this.resolvedPagePath}'. ` + `Expected a Response object but received '${invalidType}' (method: ${request.method}, url: ${requestStore.url.pathname}). ` + `Ensure you return a \`Response\` or a \`NextResponse\` in all branches of your handler.`), "__NEXT_ERROR_CODE", {
|
||||
value: "E985",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
context.renderOpts.fetchMetrics = workStore.fetchMetrics;
|
||||
resolvePendingRevalidations();
|
||||
if (prerenderStore) {
|
||||
var _prerenderStore_tags;
|
||||
context.renderOpts.collectedTags = (_prerenderStore_tags = prerenderStore.tags) == null ? void 0 : _prerenderStore_tags.join(',');
|
||||
context.renderOpts.collectedRevalidate = prerenderStore.revalidate;
|
||||
context.renderOpts.collectedExpire = prerenderStore.expire;
|
||||
context.renderOpts.collectedStale = prerenderStore.stale;
|
||||
}
|
||||
// It's possible cookies were set in the handler, so we need
|
||||
// to merge the modified cookies and the returned response
|
||||
// here.
|
||||
const headers = new Headers(res.headers);
|
||||
if ((0, _requestcookies.appendMutableCookies)(headers, requestStore.mutableCookies)) {
|
||||
return new Response(res.body, {
|
||||
status: res.status,
|
||||
statusText: res.statusText,
|
||||
headers
|
||||
});
|
||||
}
|
||||
return res;
|
||||
}
|
||||
async handle(req, context) {
|
||||
// Get the handler function for the given method. In Turbopack dev mode,
|
||||
// use resolveWithGetter() to re-fetch the live userland on every request
|
||||
// In all other modes, resolve() is synchronous.
|
||||
const handler = this._getUserland ? await this.resolveWithGetter(req.method, this._getUserland) : this.resolve(req.method);
|
||||
// Get the context for the static generation.
|
||||
const staticGenerationContext = {
|
||||
page: this.definition.page,
|
||||
renderOpts: context.renderOpts,
|
||||
buildId: context.sharedContext.buildId,
|
||||
deploymentId: context.sharedContext.deploymentId,
|
||||
previouslyRevalidatedTags: []
|
||||
};
|
||||
// Add the fetchCache option to the renderOpts.
|
||||
staticGenerationContext.renderOpts.fetchCache = this.userland.fetchCache;
|
||||
const actionStore = {
|
||||
isAppRoute: true,
|
||||
isAction: (0, _serveractionrequestmeta.getIsPossibleServerAction)(req)
|
||||
};
|
||||
const implicitTags = await (0, _implicittags.getImplicitTags)(this.definition.page, req.nextUrl.pathname, // App Routes don't support unknown route params.
|
||||
null);
|
||||
const requestStore = (0, _requeststore.createRequestStoreForAPI)(req, req.nextUrl, implicitTags, undefined, context.previewProps);
|
||||
const workStore = (0, _workstore.createWorkStore)(staticGenerationContext);
|
||||
// Run the handler with the request AsyncLocalStorage to inject the helper
|
||||
// support. We set this to `unknown` because the type is not known until
|
||||
// runtime when we do a instanceof check below.
|
||||
const response = await this.actionAsyncStorage.run(actionStore, ()=>this.workUnitAsyncStorage.run(requestStore, ()=>this.workAsyncStorage.run(workStore, async ()=>{
|
||||
// Check to see if we should bail out of static generation based on
|
||||
// having non-static methods.
|
||||
if (hasNonStaticMethods(this.userland)) {
|
||||
if (workStore.isStaticGeneration) {
|
||||
const err = Object.defineProperty(new _hooksservercontext.DynamicServerError('Route is configured with methods that cannot be statically generated.'), "__NEXT_ERROR_CODE", {
|
||||
value: "E582",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
workStore.dynamicUsageDescription = err.message;
|
||||
workStore.dynamicUsageStack = err.stack;
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
// We assume we can pass the original request through however we may end up
|
||||
// proxying it in certain circumstances based on execution type and configuration
|
||||
let request = req;
|
||||
// Update the static generation store based on the dynamic property.
|
||||
const { dynamic } = this.userland;
|
||||
switch(dynamic){
|
||||
case 'force-dynamic':
|
||||
{
|
||||
// Routes of generated paths should be dynamic
|
||||
workStore.forceDynamic = true;
|
||||
if (workStore.isStaticGeneration) {
|
||||
const err = Object.defineProperty(new _hooksservercontext.DynamicServerError('Route is configured with dynamic = error which cannot be statically generated.'), "__NEXT_ERROR_CODE", {
|
||||
value: "E703",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
workStore.dynamicUsageDescription = err.message;
|
||||
workStore.dynamicUsageStack = err.stack;
|
||||
throw err;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'force-static':
|
||||
// The dynamic property is set to force-static, so we should
|
||||
// force the page to be static.
|
||||
workStore.forceStatic = true;
|
||||
// We also Proxy the request to replace dynamic data on the request
|
||||
// with empty stubs to allow for safely executing as static
|
||||
request = new Proxy(req, forceStaticRequestHandlers);
|
||||
break;
|
||||
case 'error':
|
||||
// The dynamic property is set to error, so we should throw an
|
||||
// error if the page is being statically generated.
|
||||
workStore.dynamicShouldError = true;
|
||||
if (workStore.isStaticGeneration) request = new Proxy(req, requireStaticRequestHandlers);
|
||||
break;
|
||||
case undefined:
|
||||
case 'auto':
|
||||
// We proxy `NextRequest` to track dynamic access, and
|
||||
// potentially bail out of static generation.
|
||||
request = proxyNextRequest(req, workStore);
|
||||
break;
|
||||
default:
|
||||
dynamic;
|
||||
}
|
||||
const tracer = (0, _tracer.getTracer)();
|
||||
// Update the root span attribute for the route.
|
||||
const { pathname } = this.definition;
|
||||
tracer.setRootSpanAttribute('next.route', pathname);
|
||||
return tracer.trace(_constants.AppRouteRouteHandlersSpan.runHandler, {
|
||||
spanName: `executing api route (app) ${pathname}`,
|
||||
attributes: {
|
||||
'next.route': pathname
|
||||
}
|
||||
}, async ()=>this.do(handler, actionStore, workStore, requestStore, implicitTags, request, context));
|
||||
})));
|
||||
// If the handler did't return a valid response, then return the internal
|
||||
// error response.
|
||||
if (!(response instanceof Response)) {
|
||||
// TODO: validate the correct handling behavior, maybe log something?
|
||||
return new Response(null, {
|
||||
status: 500
|
||||
});
|
||||
}
|
||||
if (response.headers.has('x-middleware-rewrite')) {
|
||||
throw Object.defineProperty(new Error('NextResponse.rewrite() was used in a app route handler, this is not currently supported. Please remove the invocation to continue.'), "__NEXT_ERROR_CODE", {
|
||||
value: "E374",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
if (response.headers.get('x-middleware-next') === '1') {
|
||||
// TODO: move this error into the `NextResponse.next()` function.
|
||||
throw Object.defineProperty(new Error('NextResponse.next() was used in a app route handler, this is not supported. See here for more info: https://nextjs.org/docs/messages/next-response-next-in-app-route-handler'), "__NEXT_ERROR_CODE", {
|
||||
value: "E385",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
return response;
|
||||
}
|
||||
}
|
||||
const _default = AppRouteRouteModule;
|
||||
function hasNonStaticMethods(handlers) {
|
||||
if (// Order these by how common they are to be used
|
||||
handlers.POST || handlers.PUT || handlers.DELETE || handlers.PATCH || handlers.OPTIONS) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
// These symbols will be used to stash cached values on Proxied requests without requiring
|
||||
// additional closures or storage such as WeakMaps.
|
||||
const nextURLSymbol = Symbol('nextUrl');
|
||||
const requestCloneSymbol = Symbol('clone');
|
||||
const urlCloneSymbol = Symbol('clone');
|
||||
const searchParamsSymbol = Symbol('searchParams');
|
||||
const hrefSymbol = Symbol('href');
|
||||
const toStringSymbol = Symbol('toString');
|
||||
const headersSymbol = Symbol('headers');
|
||||
const cookiesSymbol = Symbol('cookies');
|
||||
/**
|
||||
* The general technique with these proxy handlers is to prioritize keeping them static
|
||||
* by stashing computed values on the Proxy itself. This is safe because the Proxy is
|
||||
* inaccessible to the consumer since all operations are forwarded
|
||||
*/ const forceStaticRequestHandlers = {
|
||||
get (target, prop, receiver) {
|
||||
switch(prop){
|
||||
case 'headers':
|
||||
return target[headersSymbol] || (target[headersSymbol] = _headers.HeadersAdapter.seal(new Headers({})));
|
||||
case 'cookies':
|
||||
return target[cookiesSymbol] || (target[cookiesSymbol] = _requestcookies.RequestCookiesAdapter.seal(new _cookies.RequestCookies(new Headers({}))));
|
||||
case 'nextUrl':
|
||||
return target[nextURLSymbol] || (target[nextURLSymbol] = new Proxy(target.nextUrl, forceStaticNextUrlHandlers));
|
||||
case 'url':
|
||||
// we don't need to separately cache this we can just read the nextUrl
|
||||
// and return the href since we know it will have been stripped of any
|
||||
// dynamic parts. We access via the receiver to trigger the get trap
|
||||
return receiver.nextUrl.href;
|
||||
case 'geo':
|
||||
case 'ip':
|
||||
return undefined;
|
||||
case 'clone':
|
||||
return target[requestCloneSymbol] || (target[requestCloneSymbol] = ()=>new Proxy(// This is vaguely unsafe but it's required since NextRequest does not implement
|
||||
// clone. The reason we might expect this to work in this context is the Proxy will
|
||||
// respond with static-amenable values anyway somewhat restoring the interface.
|
||||
// @TODO we need to rethink NextRequest and NextURL because they are not sufficientlly
|
||||
// sophisticated to adequately represent themselves in all contexts. A better approach is
|
||||
// to probably embed the static generation logic into the class itself removing the need
|
||||
// for any kind of proxying
|
||||
target.clone(), forceStaticRequestHandlers));
|
||||
default:
|
||||
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
||||
}
|
||||
}
|
||||
};
|
||||
const forceStaticNextUrlHandlers = {
|
||||
get (target, prop, receiver) {
|
||||
switch(prop){
|
||||
// URL properties
|
||||
case 'search':
|
||||
return '';
|
||||
case 'searchParams':
|
||||
return target[searchParamsSymbol] || (target[searchParamsSymbol] = new URLSearchParams());
|
||||
case 'href':
|
||||
return target[hrefSymbol] || (target[hrefSymbol] = (0, _cleanurl.cleanURL)(target.href).href);
|
||||
case 'toJSON':
|
||||
case 'toString':
|
||||
return target[toStringSymbol] || (target[toStringSymbol] = ()=>receiver.href);
|
||||
// NextUrl properties
|
||||
case 'url':
|
||||
// Currently nextURL does not expose url but our Docs indicate that it is an available property
|
||||
// I am forcing this to undefined here to avoid accidentally exposing a dynamic value later if
|
||||
// the underlying nextURL ends up adding this property
|
||||
return undefined;
|
||||
case 'clone':
|
||||
return target[urlCloneSymbol] || (target[urlCloneSymbol] = ()=>new Proxy(target.clone(), forceStaticNextUrlHandlers));
|
||||
default:
|
||||
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
||||
}
|
||||
}
|
||||
};
|
||||
function proxyNextRequest(request, workStore) {
|
||||
const nextUrlHandlers = {
|
||||
get (target, prop, receiver) {
|
||||
switch(prop){
|
||||
case 'search':
|
||||
case 'searchParams':
|
||||
case 'url':
|
||||
case 'href':
|
||||
case 'toJSON':
|
||||
case 'toString':
|
||||
case 'origin':
|
||||
{
|
||||
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
||||
trackDynamic(workStore, workUnitStore, `nextUrl.${prop}`);
|
||||
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
||||
}
|
||||
case 'clone':
|
||||
return target[urlCloneSymbol] || (target[urlCloneSymbol] = ()=>new Proxy(target.clone(), nextUrlHandlers));
|
||||
default:
|
||||
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
||||
}
|
||||
}
|
||||
};
|
||||
const nextRequestHandlers = {
|
||||
get (target, prop) {
|
||||
switch(prop){
|
||||
case 'nextUrl':
|
||||
return target[nextURLSymbol] || (target[nextURLSymbol] = new Proxy(target.nextUrl, nextUrlHandlers));
|
||||
case 'headers':
|
||||
case 'cookies':
|
||||
case 'url':
|
||||
case 'body':
|
||||
case 'blob':
|
||||
case 'json':
|
||||
case 'text':
|
||||
case 'arrayBuffer':
|
||||
case 'formData':
|
||||
{
|
||||
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
||||
trackDynamic(workStore, workUnitStore, `request.${prop}`);
|
||||
// The receiver arg is intentionally the same as the target to fix an issue with
|
||||
// edge runtime, where attempting to access internal slots with the wrong `this` context
|
||||
// results in an error.
|
||||
return _reflect.ReflectAdapter.get(target, prop, target);
|
||||
}
|
||||
case 'clone':
|
||||
return target[requestCloneSymbol] || (target[requestCloneSymbol] = ()=>new Proxy(// This is vaguely unsafe but it's required since NextRequest does not implement
|
||||
// clone. The reason we might expect this to work in this context is the Proxy will
|
||||
// respond with static-amenable values anyway somewhat restoring the interface.
|
||||
// @TODO we need to rethink NextRequest and NextURL because they are not sufficientlly
|
||||
// sophisticated to adequately represent themselves in all contexts. A better approach is
|
||||
// to probably embed the static generation logic into the class itself removing the need
|
||||
// for any kind of proxying
|
||||
target.clone(), nextRequestHandlers));
|
||||
default:
|
||||
// The receiver arg is intentionally the same as the target to fix an issue with
|
||||
// edge runtime, where attempting to access internal slots with the wrong `this` context
|
||||
// results in an error.
|
||||
return _reflect.ReflectAdapter.get(target, prop, target);
|
||||
}
|
||||
}
|
||||
};
|
||||
return new Proxy(request, nextRequestHandlers);
|
||||
}
|
||||
const requireStaticRequestHandlers = {
|
||||
get (target, prop, receiver) {
|
||||
switch(prop){
|
||||
case 'nextUrl':
|
||||
return target[nextURLSymbol] || (target[nextURLSymbol] = new Proxy(target.nextUrl, requireStaticNextUrlHandlers));
|
||||
case 'headers':
|
||||
case 'cookies':
|
||||
case 'url':
|
||||
case 'body':
|
||||
case 'blob':
|
||||
case 'json':
|
||||
case 'text':
|
||||
case 'arrayBuffer':
|
||||
case 'formData':
|
||||
throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${target.nextUrl.pathname} with \`dynamic = "error"\` couldn't be rendered statically because it used \`request.${prop}\`.`), "__NEXT_ERROR_CODE", {
|
||||
value: "E611",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
case 'clone':
|
||||
return target[requestCloneSymbol] || (target[requestCloneSymbol] = ()=>new Proxy(// This is vaguely unsafe but it's required since NextRequest does not implement
|
||||
// clone. The reason we might expect this to work in this context is the Proxy will
|
||||
// respond with static-amenable values anyway somewhat restoring the interface.
|
||||
// @TODO we need to rethink NextRequest and NextURL because they are not sufficientlly
|
||||
// sophisticated to adequately represent themselves in all contexts. A better approach is
|
||||
// to probably embed the static generation logic into the class itself removing the need
|
||||
// for any kind of proxying
|
||||
target.clone(), requireStaticRequestHandlers));
|
||||
default:
|
||||
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
||||
}
|
||||
}
|
||||
};
|
||||
const requireStaticNextUrlHandlers = {
|
||||
get (target, prop, receiver) {
|
||||
switch(prop){
|
||||
case 'search':
|
||||
case 'searchParams':
|
||||
case 'url':
|
||||
case 'href':
|
||||
case 'toJSON':
|
||||
case 'toString':
|
||||
case 'origin':
|
||||
throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${target.pathname} with \`dynamic = "error"\` couldn't be rendered statically because it used \`nextUrl.${prop}\`.`), "__NEXT_ERROR_CODE", {
|
||||
value: "E575",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
case 'clone':
|
||||
return target[urlCloneSymbol] || (target[urlCloneSymbol] = ()=>new Proxy(target.clone(), requireStaticNextUrlHandlers));
|
||||
default:
|
||||
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
||||
}
|
||||
}
|
||||
};
|
||||
function createCacheComponentsError(route) {
|
||||
return Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${route} couldn't be rendered statically because it used IO that was not cached. See more info here: https://nextjs.org/docs/messages/cache-components`), "__NEXT_ERROR_CODE", {
|
||||
value: "E727",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
function trackDynamic(store, workUnitStore, expression) {
|
||||
if (store.dynamicShouldError) {
|
||||
throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${store.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
|
||||
value: "E553",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
if (workUnitStore) {
|
||||
switch(workUnitStore.type){
|
||||
case 'cache':
|
||||
case 'private-cache':
|
||||
// TODO: Should we allow reading cookies and search params from the
|
||||
// request for private caches in route handlers?
|
||||
throw Object.defineProperty(new Error(`Route ${store.route} used "${expression}" inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use "${expression}" outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
|
||||
value: "E178",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
case 'unstable-cache':
|
||||
throw Object.defineProperty(new Error(`Route ${store.route} used "${expression}" inside a function cached with "unstable_cache(...)". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use "${expression}" outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
|
||||
value: "E133",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
case 'prerender':
|
||||
const error = Object.defineProperty(new Error(`Route ${store.route} used ${expression} without first calling \`await connection()\`. See more info here: https://nextjs.org/docs/messages/next-prerender-sync-request`), "__NEXT_ERROR_CODE", {
|
||||
value: "E261",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
return (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(store.route, expression, error, workUnitStore);
|
||||
case 'prerender-client':
|
||||
case 'validation-client':
|
||||
throw Object.defineProperty(new _invarianterror.InvariantError('A client prerender store should not be used for a route handler.'), "__NEXT_ERROR_CODE", {
|
||||
value: "E720",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
case 'prerender-runtime':
|
||||
throw Object.defineProperty(new _invarianterror.InvariantError('A runtime prerender store should not be used for a route handler.'), "__NEXT_ERROR_CODE", {
|
||||
value: "E767",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
case 'prerender-ppr':
|
||||
return (0, _dynamicrendering.postponeWithTracking)(store.route, expression, workUnitStore.dynamicTracking);
|
||||
case 'prerender-legacy':
|
||||
workUnitStore.revalidate = 0;
|
||||
const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
|
||||
value: "E558",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
store.dynamicUsageDescription = expression;
|
||||
store.dynamicUsageStack = err.stack;
|
||||
throw err;
|
||||
case 'request':
|
||||
if (process.env.NODE_ENV !== 'production') {
|
||||
// TODO: This is currently not really needed for route handlers, as it
|
||||
// only controls the ISR status that's shown for pages.
|
||||
workUnitStore.usedDynamic = true;
|
||||
}
|
||||
break;
|
||||
case 'generate-static-params':
|
||||
break;
|
||||
default:
|
||||
workUnitStore;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=module.js.map
|
||||
56
build/node_modules/next/dist/server/route-modules/app-route/shared-modules.js
generated
vendored
56
build/node_modules/next/dist/server/route-modules/app-route/shared-modules.js
generated
vendored
@@ -1,56 +0,0 @@
|
||||
// the name of the export has to be the camelCase version of the file name (without the extension)
|
||||
// TODO: remove this. We need it because using notFound from next/navigation imports this file :(
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "appRouterContext", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return _approutercontextsharedruntime;
|
||||
}
|
||||
});
|
||||
const _approutercontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../shared/lib/app-router-context.shared-runtime"));
|
||||
function _getRequireWildcardCache(nodeInterop) {
|
||||
if (typeof WeakMap !== "function") return null;
|
||||
var cacheBabelInterop = new WeakMap();
|
||||
var cacheNodeInterop = new WeakMap();
|
||||
return (_getRequireWildcardCache = function(nodeInterop) {
|
||||
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
|
||||
})(nodeInterop);
|
||||
}
|
||||
function _interop_require_wildcard(obj, nodeInterop) {
|
||||
if (!nodeInterop && obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
|
||||
return {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
var cache = _getRequireWildcardCache(nodeInterop);
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {
|
||||
__proto__: null
|
||||
};
|
||||
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for(var key in obj){
|
||||
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=shared-modules.js.map
|
||||
45
build/node_modules/next/dist/server/route-modules/checks.js
generated
vendored
45
build/node_modules/next/dist/server/route-modules/checks.js
generated
vendored
@@ -1,45 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
isAppPageRouteModule: null,
|
||||
isAppRouteRouteModule: null,
|
||||
isPagesAPIRouteModule: null,
|
||||
isPagesRouteModule: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
isAppPageRouteModule: function() {
|
||||
return isAppPageRouteModule;
|
||||
},
|
||||
isAppRouteRouteModule: function() {
|
||||
return isAppRouteRouteModule;
|
||||
},
|
||||
isPagesAPIRouteModule: function() {
|
||||
return isPagesAPIRouteModule;
|
||||
},
|
||||
isPagesRouteModule: function() {
|
||||
return isPagesRouteModule;
|
||||
}
|
||||
});
|
||||
const _routekind = require("../route-kind");
|
||||
function isAppRouteRouteModule(routeModule) {
|
||||
return routeModule.definition.kind === _routekind.RouteKind.APP_ROUTE;
|
||||
}
|
||||
function isAppPageRouteModule(routeModule) {
|
||||
return routeModule.definition.kind === _routekind.RouteKind.APP_PAGE;
|
||||
}
|
||||
function isPagesRouteModule(routeModule) {
|
||||
return routeModule.definition.kind === _routekind.RouteKind.PAGES;
|
||||
}
|
||||
function isPagesAPIRouteModule(routeModule) {
|
||||
return routeModule.definition.kind === _routekind.RouteKind.PAGES_API;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=checks.js.map
|
||||
20
build/node_modules/next/dist/server/route-modules/pages-api/module.compiled.js
generated
vendored
20
build/node_modules/next/dist/server/route-modules/pages-api/module.compiled.js
generated
vendored
@@ -1,20 +0,0 @@
|
||||
"use strict";
|
||||
if (process.env.NEXT_RUNTIME === 'edge') {
|
||||
module.exports = require('next/dist/server/route-modules/pages-api/module.js');
|
||||
} else {
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
if (process.env.TURBOPACK) {
|
||||
module.exports = require('next/dist/compiled/next-server/pages-api-turbo.runtime.dev.js');
|
||||
} else {
|
||||
module.exports = require('next/dist/compiled/next-server/pages-api.runtime.dev.js');
|
||||
}
|
||||
} else {
|
||||
if (process.env.TURBOPACK) {
|
||||
module.exports = require('next/dist/compiled/next-server/pages-api-turbo.runtime.prod.js');
|
||||
} else {
|
||||
module.exports = require('next/dist/compiled/next-server/pages-api.runtime.prod.js');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=module.compiled.js.map
|
||||
58
build/node_modules/next/dist/server/route-modules/pages-api/module.js
generated
vendored
58
build/node_modules/next/dist/server/route-modules/pages-api/module.js
generated
vendored
@@ -1,58 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
PagesAPIRouteModule: null,
|
||||
default: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
PagesAPIRouteModule: function() {
|
||||
return PagesAPIRouteModule;
|
||||
},
|
||||
default: function() {
|
||||
return _default;
|
||||
}
|
||||
});
|
||||
const _apiutils = require("../../api-utils");
|
||||
const _routemodule = require("../route-module");
|
||||
const _apiresolver = require("../../api-utils/node/api-resolver");
|
||||
class PagesAPIRouteModule extends _routemodule.RouteModule {
|
||||
constructor(options){
|
||||
super(options);
|
||||
if (typeof options.userland.default !== 'function') {
|
||||
throw Object.defineProperty(new Error(`Page ${options.definition.page} does not export a default function.`), "__NEXT_ERROR_CODE", {
|
||||
value: "E379",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
this.apiResolverWrapped = (0, _apiutils.wrapApiHandler)(options.definition.page, _apiresolver.apiResolver);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param req the incoming server request
|
||||
* @param res the outgoing server response
|
||||
* @param context the context for the render
|
||||
*/ async render(req, res, context) {
|
||||
const { apiResolverWrapped } = this;
|
||||
await apiResolverWrapped(req, res, context.query, this.userland, {
|
||||
...context.previewProps,
|
||||
trustHostHeader: context.trustHostHeader,
|
||||
allowedRevalidateHeaderKeys: context.allowedRevalidateHeaderKeys,
|
||||
hostname: context.hostname,
|
||||
multiZoneDraftMode: context.multiZoneDraftMode,
|
||||
dev: context.dev,
|
||||
internalRevalidate: context.internalRevalidate
|
||||
}, context.propagateError, context.dev, context.page, context.onError);
|
||||
}
|
||||
}
|
||||
const _default = PagesAPIRouteModule;
|
||||
|
||||
//# sourceMappingURL=module.js.map
|
||||
100
build/node_modules/next/dist/server/route-modules/pages/builtin/_error.js
generated
vendored
100
build/node_modules/next/dist/server/route-modules/pages/builtin/_error.js
generated
vendored
@@ -1,100 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
handler: null,
|
||||
routeModule: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
handler: function() {
|
||||
return handler;
|
||||
},
|
||||
routeModule: function() {
|
||||
return routeModule;
|
||||
}
|
||||
});
|
||||
const _app = /*#__PURE__*/ _interop_require_default(require("../../../../pages/_app"));
|
||||
const _document = /*#__PURE__*/ _interop_require_default(require("../../../../pages/_document"));
|
||||
const _routekind = require("../../../route-kind");
|
||||
const _error = /*#__PURE__*/ _interop_require_wildcard(require("../../../../pages/_error"));
|
||||
const _module = /*#__PURE__*/ _interop_require_default(require("../module"));
|
||||
const _pageshandler = require("../pages-handler");
|
||||
function _interop_require_default(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
function _getRequireWildcardCache(nodeInterop) {
|
||||
if (typeof WeakMap !== "function") return null;
|
||||
var cacheBabelInterop = new WeakMap();
|
||||
var cacheNodeInterop = new WeakMap();
|
||||
return (_getRequireWildcardCache = function(nodeInterop) {
|
||||
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
|
||||
})(nodeInterop);
|
||||
}
|
||||
function _interop_require_wildcard(obj, nodeInterop) {
|
||||
if (!nodeInterop && obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
|
||||
return {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
var cache = _getRequireWildcardCache(nodeInterop);
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {
|
||||
__proto__: null
|
||||
};
|
||||
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for(var key in obj){
|
||||
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
const routeModule = new _module.default({
|
||||
// TODO: add descriptor for internal error page
|
||||
definition: {
|
||||
kind: _routekind.RouteKind.PAGES,
|
||||
page: '/_error',
|
||||
pathname: '/_error',
|
||||
filename: '',
|
||||
bundlePath: ''
|
||||
},
|
||||
distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
|
||||
relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',
|
||||
components: {
|
||||
App: _app.default,
|
||||
Document: _document.default
|
||||
},
|
||||
userland: _error
|
||||
});
|
||||
const handler = (0, _pageshandler.getHandler)({
|
||||
srcPage: '/_error',
|
||||
routeModule,
|
||||
userland: _error,
|
||||
config: {},
|
||||
isFallbackError: true
|
||||
});
|
||||
|
||||
//# sourceMappingURL=_error.js.map
|
||||
20
build/node_modules/next/dist/server/route-modules/pages/module.compiled.js
generated
vendored
20
build/node_modules/next/dist/server/route-modules/pages/module.compiled.js
generated
vendored
@@ -1,20 +0,0 @@
|
||||
"use strict";
|
||||
if (process.env.NEXT_RUNTIME === 'edge') {
|
||||
module.exports = require('next/dist/server/route-modules/pages/module.js');
|
||||
} else {
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
if (process.env.TURBOPACK) {
|
||||
module.exports = require('next/dist/compiled/next-server/pages-turbo.runtime.dev.js');
|
||||
} else {
|
||||
module.exports = require('next/dist/compiled/next-server/pages.runtime.dev.js');
|
||||
}
|
||||
} else {
|
||||
if (process.env.TURBOPACK) {
|
||||
module.exports = require('next/dist/compiled/next-server/pages-turbo.runtime.prod.js');
|
||||
} else {
|
||||
module.exports = require('next/dist/compiled/next-server/pages.runtime.prod.js');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=module.compiled.js.map
|
||||
92
build/node_modules/next/dist/server/route-modules/pages/module.js
generated
vendored
92
build/node_modules/next/dist/server/route-modules/pages/module.js
generated
vendored
@@ -1,92 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
PagesRouteModule: null,
|
||||
default: null,
|
||||
renderToHTML: null,
|
||||
vendored: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
PagesRouteModule: function() {
|
||||
return PagesRouteModule;
|
||||
},
|
||||
default: function() {
|
||||
return _default;
|
||||
},
|
||||
renderToHTML: function() {
|
||||
return _render.renderToHTML;
|
||||
},
|
||||
vendored: function() {
|
||||
return vendored;
|
||||
}
|
||||
});
|
||||
const _routemodule = require("../route-module");
|
||||
const _render = require("../../render");
|
||||
const _entrypoints = /*#__PURE__*/ _interop_require_wildcard(require("./vendored/contexts/entrypoints"));
|
||||
function _getRequireWildcardCache(nodeInterop) {
|
||||
if (typeof WeakMap !== "function") return null;
|
||||
var cacheBabelInterop = new WeakMap();
|
||||
var cacheNodeInterop = new WeakMap();
|
||||
return (_getRequireWildcardCache = function(nodeInterop) {
|
||||
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
|
||||
})(nodeInterop);
|
||||
}
|
||||
function _interop_require_wildcard(obj, nodeInterop) {
|
||||
if (!nodeInterop && obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
|
||||
return {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
var cache = _getRequireWildcardCache(nodeInterop);
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {
|
||||
__proto__: null
|
||||
};
|
||||
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for(var key in obj){
|
||||
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
class PagesRouteModule extends _routemodule.RouteModule {
|
||||
constructor(options){
|
||||
super(options);
|
||||
this.components = options.components;
|
||||
}
|
||||
render(req, res, context) {
|
||||
return (0, _render.renderToHTMLImpl)(req, res, context.page, context.query, context.renderOpts, {
|
||||
App: this.components.App,
|
||||
Document: this.components.Document
|
||||
}, context.sharedContext, context.renderContext);
|
||||
}
|
||||
}
|
||||
const vendored = {
|
||||
contexts: _entrypoints
|
||||
};
|
||||
const _default = PagesRouteModule;
|
||||
|
||||
//# sourceMappingURL=module.js.map
|
||||
24
build/node_modules/next/dist/server/route-modules/pages/module.render.js
generated
vendored
24
build/node_modules/next/dist/server/route-modules/pages/module.render.js
generated
vendored
@@ -1,24 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "lazyRenderPagesPage", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return lazyRenderPagesPage;
|
||||
}
|
||||
});
|
||||
const lazyRenderPagesPage = (...args)=>{
|
||||
if (process.env.NEXT_MINIMAL) {
|
||||
throw Object.defineProperty(new Error("Can't use lazyRenderPagesPage in minimal mode"), "__NEXT_ERROR_CODE", {
|
||||
value: "E272",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
} else {
|
||||
const render = require('./module.compiled').renderToHTML;
|
||||
return render(...args);
|
||||
}
|
||||
};
|
||||
|
||||
//# sourceMappingURL=module.render.js.map
|
||||
545
build/node_modules/next/dist/server/route-modules/pages/pages-handler.js
generated
vendored
545
build/node_modules/next/dist/server/route-modules/pages/pages-handler.js
generated
vendored
@@ -1,545 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "getHandler", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return getHandler;
|
||||
}
|
||||
});
|
||||
const _routekind = require("../../route-kind");
|
||||
const _constants = require("../../lib/trace/constants");
|
||||
const _tracer = require("../../lib/trace/tracer");
|
||||
const _formaturl = require("../../../shared/lib/router/utils/format-url");
|
||||
const _requestmeta = require("../../request-meta");
|
||||
const _interopdefault = require("../../app-render/interop-default");
|
||||
const _utils = require("../../instrumentation/utils");
|
||||
const _normalizedatapath = require("../../../shared/lib/page-path/normalize-data-path");
|
||||
const _responsecache = require("../../response-cache");
|
||||
const _cachecontrol = require("../../lib/cache-control");
|
||||
const _utils1 = require("../../../shared/lib/utils");
|
||||
const _redirectstatus = require("../../../lib/redirect-status");
|
||||
const _constants1 = require("../../../lib/constants");
|
||||
const _path = /*#__PURE__*/ _interop_require_default(require("path"));
|
||||
const _sendpayload = require("../../send-payload");
|
||||
const _renderresult = /*#__PURE__*/ _interop_require_default(require("../../render-result"));
|
||||
const _utils2 = require("../../response-cache/utils");
|
||||
const _nofallbackerrorexternal = require("../../../shared/lib/no-fallback-error.external");
|
||||
const _redirectstatuscode = require("../../../client/components/redirect-status-code");
|
||||
const _isbot = require("../../../shared/lib/router/utils/is-bot");
|
||||
const _addpathprefix = require("../../../shared/lib/router/utils/add-path-prefix");
|
||||
const _removetrailingslash = require("../../../shared/lib/router/utils/remove-trailing-slash");
|
||||
function _interop_require_default(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, isFallbackError, getStaticPaths, getStaticProps, getServerSideProps })=>{
|
||||
return async function handler(req, res, ctx) {
|
||||
var _serverFilesManifest_config_experimental, _serverFilesManifest_config;
|
||||
if (ctx.requestMeta) {
|
||||
(0, _requestmeta.setRequestMeta)(req, ctx.requestMeta);
|
||||
}
|
||||
if (routeModule.isDev) {
|
||||
(0, _requestmeta.addRequestMeta)(req, 'devRequestTimingInternalsEnd', process.hrtime.bigint());
|
||||
}
|
||||
let srcPage = originalSrcPage;
|
||||
// turbopack doesn't normalize `/index` in the page name
|
||||
// so we need to to process dynamic routes properly
|
||||
// TODO: fix turbopack providing differing value from webpack
|
||||
if (process.env.TURBOPACK) {
|
||||
srcPage = srcPage.replace(/\/index$/, '') || '/';
|
||||
} else if (srcPage === '/index') {
|
||||
// we always normalize /index specifically
|
||||
srcPage = '/';
|
||||
}
|
||||
const multiZoneDraftMode = process.env.__NEXT_MULTI_ZONE_DRAFT_MODE;
|
||||
const prepareResult = await routeModule.prepare(req, res, {
|
||||
srcPage,
|
||||
multiZoneDraftMode
|
||||
});
|
||||
if (!prepareResult) {
|
||||
res.statusCode = 400;
|
||||
res.end('Bad Request');
|
||||
ctx.waitUntil == null ? void 0 : ctx.waitUntil.call(ctx, Promise.resolve());
|
||||
return;
|
||||
}
|
||||
const isMinimalMode = Boolean((0, _requestmeta.getRequestMeta)(req, 'minimalMode'));
|
||||
const render404 = async ()=>{
|
||||
// TODO: should route-module itself handle rendering the 404
|
||||
if (routerServerContext == null ? void 0 : routerServerContext.render404) {
|
||||
await routerServerContext.render404(req, res, parsedUrl, false);
|
||||
} else {
|
||||
res.end('This page could not be found');
|
||||
}
|
||||
};
|
||||
const { buildId, query, params, parsedUrl, originalQuery, originalPathname, buildManifest, fallbackBuildManifest, nextFontManifest, serverFilesManifest, reactLoadableManifest, prerenderManifest, isDraftMode, isOnDemandRevalidate, revalidateOnlyGenerated, locale, locales, defaultLocale, routerServerContext, nextConfig, resolvedPathname, encodedResolvedPathname, deploymentId, clientAssetToken } = prepareResult;
|
||||
const isExperimentalCompile = serverFilesManifest == null ? void 0 : (_serverFilesManifest_config = serverFilesManifest.config) == null ? void 0 : (_serverFilesManifest_config_experimental = _serverFilesManifest_config.experimental) == null ? void 0 : _serverFilesManifest_config_experimental.isExperimentalCompile;
|
||||
const hasServerProps = Boolean(getServerSideProps);
|
||||
const hasStaticProps = Boolean(getStaticProps);
|
||||
const hasStaticPaths = Boolean(getStaticPaths);
|
||||
const hasGetInitialProps = Boolean((userland.default || userland).getInitialProps);
|
||||
let cacheKey = null;
|
||||
let isIsrFallback = false;
|
||||
let isNextDataRequest = prepareResult.isNextDataRequest && (hasStaticProps || hasServerProps);
|
||||
const is404Page = srcPage === '/404';
|
||||
const is500Page = srcPage === '/500';
|
||||
const isErrorPage = srcPage === '/_error';
|
||||
if (!routeModule.isDev && !isDraftMode && hasStaticProps) {
|
||||
cacheKey = `${locale ? `/${locale}` : ''}${(srcPage === '/' || resolvedPathname === '/') && locale ? '' : resolvedPathname}`;
|
||||
if (is404Page || is500Page || isErrorPage) {
|
||||
cacheKey = `${locale ? `/${locale}` : ''}${srcPage}`;
|
||||
}
|
||||
// ensure /index and / is normalized to one key
|
||||
cacheKey = cacheKey === '/index' ? '/' : cacheKey;
|
||||
}
|
||||
if (hasStaticPaths && !isDraftMode) {
|
||||
const decodedPathname = (0, _removetrailingslash.removeTrailingSlash)(locale ? (0, _addpathprefix.addPathPrefix)(resolvedPathname, `/${locale}`) : resolvedPathname);
|
||||
const isPrerendered = Boolean(prerenderManifest.routes[decodedPathname]) || prerenderManifest.notFoundRoutes.includes(decodedPathname);
|
||||
const prerenderInfo = prerenderManifest.dynamicRoutes[srcPage];
|
||||
if (prerenderInfo) {
|
||||
if (prerenderInfo.fallback === false && !isPrerendered) {
|
||||
if (nextConfig.adapterPath) {
|
||||
return await render404();
|
||||
}
|
||||
throw new _nofallbackerrorexternal.NoFallbackError();
|
||||
}
|
||||
if (typeof prerenderInfo.fallback === 'string' && !isPrerendered && !isNextDataRequest) {
|
||||
isIsrFallback = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
// When serving a bot request, we want to serve a blocking render and not
|
||||
// the prerendered page. This ensures that the correct content is served
|
||||
// to the bot in the head.
|
||||
if (isIsrFallback && (0, _isbot.isBot)(req.headers['user-agent'] || '') || isMinimalMode) {
|
||||
isIsrFallback = false;
|
||||
}
|
||||
const tracer = (0, _tracer.getTracer)();
|
||||
const activeSpan = tracer.getActiveScopeSpan();
|
||||
try {
|
||||
var _parsedUrl_pathname;
|
||||
const method = req.method || 'GET';
|
||||
const resolvedUrl = (0, _formaturl.formatUrl)({
|
||||
pathname: nextConfig.trailingSlash ? `${encodedResolvedPathname}${!encodedResolvedPathname.endsWith('/') && ((_parsedUrl_pathname = parsedUrl.pathname) == null ? void 0 : _parsedUrl_pathname.endsWith('/')) ? '/' : ''}` : (0, _removetrailingslash.removeTrailingSlash)(encodedResolvedPathname || '/'),
|
||||
// make sure to only add query values from original URL
|
||||
query: hasStaticProps ? {} : originalQuery
|
||||
});
|
||||
let parentSpan;
|
||||
const handleResponse = async (span)=>{
|
||||
const responseGenerator = async ({ previousCacheEntry })=>{
|
||||
var _previousCacheEntry_value;
|
||||
const doRender = async ()=>{
|
||||
try {
|
||||
var _nextConfig_i18n;
|
||||
return await routeModule.render(req, res, {
|
||||
query: hasStaticProps && !isExperimentalCompile ? {
|
||||
...params
|
||||
} : {
|
||||
...query,
|
||||
...params
|
||||
},
|
||||
params,
|
||||
page: srcPage,
|
||||
renderContext: {
|
||||
isDraftMode,
|
||||
isFallback: isIsrFallback,
|
||||
developmentNotFoundSourcePage: (0, _requestmeta.getRequestMeta)(req, 'developmentNotFoundSourcePage')
|
||||
},
|
||||
sharedContext: {
|
||||
buildId,
|
||||
customServer: Boolean(routerServerContext == null ? void 0 : routerServerContext.isCustomServer) || undefined,
|
||||
deploymentId,
|
||||
clientAssetToken
|
||||
},
|
||||
renderOpts: {
|
||||
params,
|
||||
routeModule,
|
||||
page: srcPage,
|
||||
pageConfig: config || {},
|
||||
Component: (0, _interopdefault.interopDefault)(userland),
|
||||
ComponentMod: userland,
|
||||
getStaticProps,
|
||||
getStaticPaths,
|
||||
getServerSideProps,
|
||||
supportsDynamicResponse: !hasStaticProps,
|
||||
buildManifest: isFallbackError ? fallbackBuildManifest : buildManifest,
|
||||
nextFontManifest,
|
||||
reactLoadableManifest,
|
||||
assetPrefix: nextConfig.assetPrefix,
|
||||
previewProps: prerenderManifest.preview,
|
||||
images: nextConfig.images,
|
||||
nextConfigOutput: nextConfig.output,
|
||||
optimizeCss: Boolean(nextConfig.experimental.optimizeCss),
|
||||
nextScriptWorkers: Boolean(nextConfig.experimental.nextScriptWorkers),
|
||||
domainLocales: (_nextConfig_i18n = nextConfig.i18n) == null ? void 0 : _nextConfig_i18n.domains,
|
||||
crossOrigin: nextConfig.crossOrigin,
|
||||
multiZoneDraftMode,
|
||||
basePath: nextConfig.basePath,
|
||||
disableOptimizedLoading: nextConfig.experimental.disableOptimizedLoading,
|
||||
largePageDataBytes: nextConfig.experimental.largePageDataBytes,
|
||||
isExperimentalCompile,
|
||||
experimental: {
|
||||
clientTraceMetadata: nextConfig.experimental.clientTraceMetadata || []
|
||||
},
|
||||
locale,
|
||||
locales,
|
||||
defaultLocale,
|
||||
setIsrStatus: routerServerContext == null ? void 0 : routerServerContext.setIsrStatus,
|
||||
isNextDataRequest: isNextDataRequest && (hasServerProps || hasStaticProps),
|
||||
resolvedUrl,
|
||||
// For getServerSideProps and getInitialProps we need to ensure we use the original URL
|
||||
// and not the resolved URL to prevent a hydration mismatch on
|
||||
// asPath
|
||||
resolvedAsPath: hasServerProps || hasGetInitialProps ? (0, _formaturl.formatUrl)({
|
||||
// we use the original URL pathname less the _next/data prefix if
|
||||
// present
|
||||
pathname: isNextDataRequest ? (0, _normalizedatapath.normalizeDataPath)(originalPathname) : originalPathname,
|
||||
query: originalQuery
|
||||
}) : resolvedUrl,
|
||||
isOnDemandRevalidate,
|
||||
ErrorDebug: (0, _requestmeta.getRequestMeta)(req, 'PagesErrorDebug'),
|
||||
err: (0, _requestmeta.getRequestMeta)(req, 'invokeError'),
|
||||
// needed for experimental.optimizeCss feature
|
||||
distDir: _path.default.join(/* turbopackIgnore: true */ process.cwd(), routeModule.relativeProjectDir, routeModule.distDir)
|
||||
}
|
||||
}).then((renderResult)=>{
|
||||
const { metadata } = renderResult;
|
||||
let cacheControl = metadata.cacheControl;
|
||||
if ('isNotFound' in metadata && metadata.isNotFound) {
|
||||
return {
|
||||
value: null,
|
||||
cacheControl
|
||||
};
|
||||
}
|
||||
// Handle `isRedirect`.
|
||||
if (metadata.isRedirect) {
|
||||
return {
|
||||
value: {
|
||||
kind: _responsecache.CachedRouteKind.REDIRECT,
|
||||
props: metadata.pageData ?? metadata.flightData
|
||||
},
|
||||
cacheControl
|
||||
};
|
||||
}
|
||||
return {
|
||||
value: {
|
||||
kind: _responsecache.CachedRouteKind.PAGES,
|
||||
html: renderResult,
|
||||
pageData: renderResult.metadata.pageData,
|
||||
headers: renderResult.metadata.headers,
|
||||
status: renderResult.metadata.statusCode
|
||||
},
|
||||
cacheControl
|
||||
};
|
||||
}).finally(()=>{
|
||||
if (!span) return;
|
||||
span.setAttributes({
|
||||
'http.status_code': res.statusCode,
|
||||
'next.rsc': false
|
||||
});
|
||||
const rootSpanAttributes = tracer.getRootSpanAttributes();
|
||||
// We were unable to get attributes, probably OTEL is not enabled
|
||||
if (!rootSpanAttributes) {
|
||||
return;
|
||||
}
|
||||
if (rootSpanAttributes.get('next.span_type') !== _constants.BaseServerSpan.handleRequest) {
|
||||
console.warn(`Unexpected root span type '${rootSpanAttributes.get('next.span_type')}'. Please report this Next.js issue https://github.com/vercel/next.js`);
|
||||
return;
|
||||
}
|
||||
const route = rootSpanAttributes.get('next.route');
|
||||
if (route) {
|
||||
const name = `${method} ${route}`;
|
||||
span.setAttributes({
|
||||
'next.route': route,
|
||||
'http.route': route,
|
||||
'next.span_name': name
|
||||
});
|
||||
span.updateName(name);
|
||||
// Propagate http.route to the parent span if one exists
|
||||
// (e.g. a platform-created HTTP span in adapter
|
||||
// deployments).
|
||||
if (parentSpan && parentSpan !== span) {
|
||||
parentSpan.setAttribute('http.route', route);
|
||||
parentSpan.updateName(name);
|
||||
}
|
||||
} else {
|
||||
span.updateName(`${method} ${srcPage}`);
|
||||
}
|
||||
});
|
||||
} catch (err) {
|
||||
// if this is a background revalidate we need to report
|
||||
// the request error here as it won't be bubbled
|
||||
if (previousCacheEntry == null ? void 0 : previousCacheEntry.isStale) {
|
||||
const silenceLog = false;
|
||||
await routeModule.onRequestError(req, err, {
|
||||
routerKind: 'Pages Router',
|
||||
routePath: srcPage,
|
||||
routeType: 'render',
|
||||
revalidateReason: (0, _utils.getRevalidateReason)({
|
||||
isStaticGeneration: hasStaticProps,
|
||||
isOnDemandRevalidate
|
||||
})
|
||||
}, silenceLog, routerServerContext);
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
};
|
||||
// if we've already generated this page we no longer
|
||||
// serve the fallback
|
||||
if (previousCacheEntry) {
|
||||
isIsrFallback = false;
|
||||
}
|
||||
if (isIsrFallback) {
|
||||
const fallbackResponse = await routeModule.getResponseCache(req).get(routeModule.isDev ? null : locale ? `/${locale}${srcPage}` : srcPage, async ({ previousCacheEntry: previousFallbackCacheEntry = null })=>{
|
||||
if (!routeModule.isDev) {
|
||||
return (0, _utils2.toResponseCacheEntry)(previousFallbackCacheEntry);
|
||||
}
|
||||
return doRender();
|
||||
}, {
|
||||
routeKind: _routekind.RouteKind.PAGES,
|
||||
isFallback: true,
|
||||
isRoutePPREnabled: false,
|
||||
isOnDemandRevalidate: false,
|
||||
incrementalCache: await routeModule.getIncrementalCache(req, nextConfig, prerenderManifest, isMinimalMode),
|
||||
waitUntil: ctx.waitUntil
|
||||
});
|
||||
if (fallbackResponse) {
|
||||
// Remove the cache control from the response to prevent it from being
|
||||
// used in the surrounding cache.
|
||||
delete fallbackResponse.cacheControl;
|
||||
fallbackResponse.isMiss = true;
|
||||
return fallbackResponse;
|
||||
}
|
||||
}
|
||||
if (!isMinimalMode && isOnDemandRevalidate && revalidateOnlyGenerated && !previousCacheEntry) {
|
||||
res.statusCode = 404;
|
||||
// on-demand revalidate always sets this header
|
||||
res.setHeader('x-nextjs-cache', 'REVALIDATED');
|
||||
res.end('This page could not be found');
|
||||
return null;
|
||||
}
|
||||
if (isIsrFallback && (previousCacheEntry == null ? void 0 : (_previousCacheEntry_value = previousCacheEntry.value) == null ? void 0 : _previousCacheEntry_value.kind) === _responsecache.CachedRouteKind.PAGES) {
|
||||
return {
|
||||
value: {
|
||||
kind: _responsecache.CachedRouteKind.PAGES,
|
||||
html: new _renderresult.default(Buffer.from(previousCacheEntry.value.html), {
|
||||
contentType: _constants1.HTML_CONTENT_TYPE_HEADER,
|
||||
metadata: {
|
||||
statusCode: previousCacheEntry.value.status,
|
||||
headers: previousCacheEntry.value.headers
|
||||
}
|
||||
}),
|
||||
pageData: {},
|
||||
status: previousCacheEntry.value.status,
|
||||
headers: previousCacheEntry.value.headers
|
||||
},
|
||||
cacheControl: {
|
||||
revalidate: 0,
|
||||
expire: undefined
|
||||
}
|
||||
};
|
||||
}
|
||||
return doRender();
|
||||
};
|
||||
const result = await routeModule.handleResponse({
|
||||
cacheKey,
|
||||
req,
|
||||
nextConfig,
|
||||
routeKind: _routekind.RouteKind.PAGES,
|
||||
isOnDemandRevalidate,
|
||||
revalidateOnlyGenerated,
|
||||
waitUntil: ctx.waitUntil,
|
||||
responseGenerator: responseGenerator,
|
||||
prerenderManifest,
|
||||
isMinimalMode
|
||||
});
|
||||
// if we got a cache hit this wasn't an ISR fallback
|
||||
// but it wasn't generated during build so isn't in the
|
||||
// prerender-manifest
|
||||
if (isIsrFallback && !(result == null ? void 0 : result.isMiss)) {
|
||||
isIsrFallback = false;
|
||||
}
|
||||
// response is finished is no cache entry
|
||||
if (!result) {
|
||||
return;
|
||||
}
|
||||
if (hasStaticProps && !isMinimalMode) {
|
||||
res.setHeader('x-nextjs-cache', isOnDemandRevalidate ? 'REVALIDATED' : result.isMiss ? 'MISS' : result.isStale ? 'STALE' : 'HIT');
|
||||
}
|
||||
let cacheControl;
|
||||
if (!hasStaticProps || isIsrFallback) {
|
||||
if (!res.getHeader('Cache-Control')) {
|
||||
cacheControl = {
|
||||
revalidate: 0,
|
||||
expire: undefined
|
||||
};
|
||||
}
|
||||
} else if (is404Page) {
|
||||
const notFoundRevalidate = (0, _requestmeta.getRequestMeta)(req, 'notFoundRevalidate');
|
||||
cacheControl = {
|
||||
revalidate: typeof notFoundRevalidate === 'undefined' ? 0 : notFoundRevalidate,
|
||||
expire: undefined
|
||||
};
|
||||
} else if (is500Page) {
|
||||
cacheControl = {
|
||||
revalidate: 0,
|
||||
expire: undefined
|
||||
};
|
||||
} else if (result.cacheControl) {
|
||||
// If the cache entry has a cache control with a revalidate value that's
|
||||
// a number, use it.
|
||||
if (typeof result.cacheControl.revalidate === 'number') {
|
||||
var _result_cacheControl;
|
||||
if (result.cacheControl.revalidate < 1) {
|
||||
throw Object.defineProperty(new Error(`Invalid revalidate configuration provided: ${result.cacheControl.revalidate} < 1`), "__NEXT_ERROR_CODE", {
|
||||
value: "E22",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
cacheControl = {
|
||||
revalidate: result.cacheControl.revalidate,
|
||||
expire: ((_result_cacheControl = result.cacheControl) == null ? void 0 : _result_cacheControl.expire) ?? nextConfig.expireTime
|
||||
};
|
||||
} else {
|
||||
// revalidate: false
|
||||
cacheControl = {
|
||||
revalidate: _constants1.CACHE_ONE_YEAR_SECONDS,
|
||||
expire: undefined
|
||||
};
|
||||
}
|
||||
}
|
||||
// If cache control is already set on the response we don't
|
||||
// override it to allow users to customize it via next.config
|
||||
if (cacheControl && !res.getHeader('Cache-Control')) {
|
||||
res.setHeader('Cache-Control', (0, _cachecontrol.getCacheControlHeader)(cacheControl));
|
||||
}
|
||||
// notFound: true case
|
||||
if (!result.value) {
|
||||
var _result_cacheControl1;
|
||||
// add revalidate metadata before rendering 404 page
|
||||
// so that we can use this as source of truth for the
|
||||
// cache-control header instead of what the 404 page returns
|
||||
// for the revalidate value
|
||||
(0, _requestmeta.addRequestMeta)(req, 'notFoundRevalidate', (_result_cacheControl1 = result.cacheControl) == null ? void 0 : _result_cacheControl1.revalidate);
|
||||
res.statusCode = 404;
|
||||
if (isNextDataRequest) {
|
||||
if (deploymentId) {
|
||||
res.setHeader(_constants1.NEXT_NAV_DEPLOYMENT_ID_HEADER, deploymentId);
|
||||
}
|
||||
res.end('{"notFound":true}');
|
||||
return;
|
||||
}
|
||||
return await render404();
|
||||
}
|
||||
if (result.value.kind === _responsecache.CachedRouteKind.REDIRECT) {
|
||||
if (isNextDataRequest) {
|
||||
if (deploymentId) {
|
||||
res.setHeader(_constants1.NEXT_NAV_DEPLOYMENT_ID_HEADER, deploymentId);
|
||||
}
|
||||
res.setHeader('content-type', _constants1.JSON_CONTENT_TYPE_HEADER);
|
||||
res.end(JSON.stringify(result.value.props));
|
||||
return;
|
||||
} else {
|
||||
const handleRedirect = (pageData)=>{
|
||||
const redirect = {
|
||||
destination: pageData.pageProps.__N_REDIRECT,
|
||||
statusCode: pageData.pageProps.__N_REDIRECT_STATUS,
|
||||
basePath: pageData.pageProps.__N_REDIRECT_BASE_PATH
|
||||
};
|
||||
const statusCode = (0, _redirectstatus.getRedirectStatus)(redirect);
|
||||
const { basePath } = nextConfig;
|
||||
if (basePath && redirect.basePath !== false && redirect.destination.startsWith('/')) {
|
||||
redirect.destination = `${basePath}${redirect.destination}`;
|
||||
}
|
||||
if (redirect.destination.startsWith('/')) {
|
||||
redirect.destination = (0, _utils1.normalizeRepeatedSlashes)(redirect.destination);
|
||||
}
|
||||
res.statusCode = statusCode;
|
||||
res.setHeader('Location', redirect.destination);
|
||||
if (statusCode === _redirectstatuscode.RedirectStatusCode.PermanentRedirect) {
|
||||
res.setHeader('Refresh', `0;url=${redirect.destination}`);
|
||||
}
|
||||
res.end(redirect.destination);
|
||||
};
|
||||
await handleRedirect(result.value.props);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
if (result.value.kind !== _responsecache.CachedRouteKind.PAGES) {
|
||||
throw Object.defineProperty(new Error(`Invariant: received non-pages cache entry in pages handler`), "__NEXT_ERROR_CODE", {
|
||||
value: "E695",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
// In dev, we should not cache pages for any reason.
|
||||
if (routeModule.isDev) {
|
||||
res.setHeader('Cache-Control', 'no-cache, must-revalidate');
|
||||
}
|
||||
// Draft mode should never be cached
|
||||
if (isDraftMode) {
|
||||
res.setHeader('Cache-Control', 'private, no-cache, no-store, max-age=0, must-revalidate');
|
||||
}
|
||||
// when invoking _error before pages/500 we don't actually
|
||||
// send the _error response
|
||||
if ((0, _requestmeta.getRequestMeta)(req, 'customErrorRender') || isErrorPage && isMinimalMode && res.statusCode === 500) {
|
||||
return null;
|
||||
}
|
||||
// Add deployment ID header for data requests
|
||||
if (isNextDataRequest && !isErrorPage && !is500Page) {
|
||||
if (deploymentId) {
|
||||
res.setHeader(_constants1.NEXT_NAV_DEPLOYMENT_ID_HEADER, deploymentId);
|
||||
}
|
||||
}
|
||||
await (0, _sendpayload.sendRenderResult)({
|
||||
req,
|
||||
res,
|
||||
// If we are rendering the error page it's not a data request
|
||||
// anymore
|
||||
result: isNextDataRequest && !isErrorPage && !is500Page ? new _renderresult.default(Buffer.from(JSON.stringify(result.value.pageData)), {
|
||||
contentType: _constants1.JSON_CONTENT_TYPE_HEADER,
|
||||
metadata: result.value.html.metadata
|
||||
}) : result.value.html,
|
||||
generateEtags: nextConfig.generateEtags,
|
||||
poweredByHeader: nextConfig.poweredByHeader,
|
||||
cacheControl: routeModule.isDev ? undefined : cacheControl
|
||||
});
|
||||
};
|
||||
// TODO: activeSpan code path is for when wrapped by
|
||||
// next-server can be removed when this is no longer used
|
||||
if (activeSpan) {
|
||||
await handleResponse();
|
||||
} else {
|
||||
parentSpan = tracer.getActiveScopeSpan();
|
||||
await tracer.withPropagatedContext(req.headers, ()=>tracer.trace(_constants.BaseServerSpan.handleRequest, {
|
||||
spanName: `${method} ${srcPage}`,
|
||||
kind: _tracer.SpanKind.SERVER,
|
||||
attributes: {
|
||||
'http.method': method,
|
||||
'http.target': req.url
|
||||
}
|
||||
}, handleResponse));
|
||||
}
|
||||
} catch (err) {
|
||||
if (!(err instanceof _nofallbackerrorexternal.NoFallbackError)) {
|
||||
const silenceLog = false;
|
||||
await routeModule.onRequestError(req, err, {
|
||||
routerKind: 'Pages Router',
|
||||
routePath: srcPage,
|
||||
routeType: 'render',
|
||||
revalidateReason: (0, _utils.getRevalidateReason)({
|
||||
isStaticGeneration: hasStaticProps,
|
||||
isOnDemandRevalidate
|
||||
})
|
||||
}, silenceLog, routerServerContext);
|
||||
}
|
||||
// rethrow so that we can handle serving error page
|
||||
throw err;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
//# sourceMappingURL=pages-handler.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].AppRouterContext;
|
||||
|
||||
//# sourceMappingURL=app-router-context.js.map
|
||||
102
build/node_modules/next/dist/server/route-modules/pages/vendored/contexts/entrypoints.js
generated
vendored
102
build/node_modules/next/dist/server/route-modules/pages/vendored/contexts/entrypoints.js
generated
vendored
@@ -1,102 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
AppRouterContext: null,
|
||||
HeadManagerContext: null,
|
||||
HooksClientContext: null,
|
||||
HtmlContext: null,
|
||||
ImageConfigContext: null,
|
||||
Loadable: null,
|
||||
LoadableContext: null,
|
||||
RouterContext: null,
|
||||
ServerInsertedHtml: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
AppRouterContext: function() {
|
||||
return _approutercontextsharedruntime;
|
||||
},
|
||||
HeadManagerContext: function() {
|
||||
return _headmanagercontextsharedruntime;
|
||||
},
|
||||
HooksClientContext: function() {
|
||||
return _hooksclientcontextsharedruntime;
|
||||
},
|
||||
HtmlContext: function() {
|
||||
return _htmlcontextsharedruntime;
|
||||
},
|
||||
ImageConfigContext: function() {
|
||||
return _imageconfigcontextsharedruntime;
|
||||
},
|
||||
Loadable: function() {
|
||||
return _loadablesharedruntime;
|
||||
},
|
||||
LoadableContext: function() {
|
||||
return _loadablecontextsharedruntime;
|
||||
},
|
||||
RouterContext: function() {
|
||||
return _routercontextsharedruntime;
|
||||
},
|
||||
ServerInsertedHtml: function() {
|
||||
return _serverinsertedhtmlsharedruntime;
|
||||
}
|
||||
});
|
||||
const _routercontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/router-context.shared-runtime"));
|
||||
const _loadablecontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/loadable-context.shared-runtime"));
|
||||
const _loadablesharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/loadable.shared-runtime"));
|
||||
const _imageconfigcontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/image-config-context.shared-runtime"));
|
||||
const _htmlcontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/html-context.shared-runtime"));
|
||||
const _hooksclientcontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/hooks-client-context.shared-runtime"));
|
||||
const _headmanagercontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/head-manager-context.shared-runtime"));
|
||||
const _approutercontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/app-router-context.shared-runtime"));
|
||||
const _serverinsertedhtmlsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/server-inserted-html.shared-runtime"));
|
||||
function _getRequireWildcardCache(nodeInterop) {
|
||||
if (typeof WeakMap !== "function") return null;
|
||||
var cacheBabelInterop = new WeakMap();
|
||||
var cacheNodeInterop = new WeakMap();
|
||||
return (_getRequireWildcardCache = function(nodeInterop) {
|
||||
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
|
||||
})(nodeInterop);
|
||||
}
|
||||
function _interop_require_wildcard(obj, nodeInterop) {
|
||||
if (!nodeInterop && obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
|
||||
return {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
var cache = _getRequireWildcardCache(nodeInterop);
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {
|
||||
__proto__: null
|
||||
};
|
||||
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for(var key in obj){
|
||||
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=entrypoints.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].HeadManagerContext;
|
||||
|
||||
//# sourceMappingURL=head-manager-context.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].HooksClientContext;
|
||||
|
||||
//# sourceMappingURL=hooks-client-context.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].HtmlContext;
|
||||
|
||||
//# sourceMappingURL=html-context.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].ImageConfigContext;
|
||||
|
||||
//# sourceMappingURL=image-config-context.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].LoadableContext;
|
||||
|
||||
//# sourceMappingURL=loadable-context.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].Loadable;
|
||||
|
||||
//# sourceMappingURL=loadable.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].RouterContext;
|
||||
|
||||
//# sourceMappingURL=router-context.js.map
|
||||
@@ -1,4 +0,0 @@
|
||||
"use strict";
|
||||
module.exports = require('../../module.compiled').vendored['contexts'].ServerInsertedHtml;
|
||||
|
||||
//# sourceMappingURL=server-inserted-html.js.map
|
||||
660
build/node_modules/next/dist/server/route-modules/route-module.js
generated
vendored
660
build/node_modules/next/dist/server/route-modules/route-module.js
generated
vendored
@@ -1,660 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "RouteModule", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return RouteModule;
|
||||
}
|
||||
});
|
||||
require("../../build/adapter/setup-node-env.external");
|
||||
const _constants = require("../../shared/lib/constants");
|
||||
const _url = require("../../lib/url");
|
||||
const _normalizelocalepath = require("../../shared/lib/i18n/normalize-locale-path");
|
||||
const _utils = require("../../shared/lib/router/utils");
|
||||
const _removepathprefix = require("../../shared/lib/router/utils/remove-path-prefix");
|
||||
const _serverutils = require("../server-utils");
|
||||
const _detectdomainlocale = require("../../shared/lib/i18n/detect-domain-locale");
|
||||
const _gethostname = require("../../shared/lib/get-hostname");
|
||||
const _apiutils = require("../api-utils");
|
||||
const _normalizedatapath = require("../../shared/lib/page-path/normalize-data-path");
|
||||
const _pathhasprefix = require("../../shared/lib/router/utils/path-has-prefix");
|
||||
const _requestmeta = require("../request-meta");
|
||||
const _patchsetheader = require("../lib/patch-set-header");
|
||||
const _normalizepagepath = require("../../shared/lib/page-path/normalize-page-path");
|
||||
const _ismetadataroute = require("../../lib/metadata/is-metadata-route");
|
||||
const _incrementalcache = require("../lib/incremental-cache");
|
||||
const _handlers = require("../use-cache/handlers");
|
||||
const _interopdefault = require("../app-render/interop-default");
|
||||
const _routekind = require("../route-kind");
|
||||
const _responsecache = /*#__PURE__*/ _interop_require_default(require("../response-cache"));
|
||||
const _apppaths = require("../../shared/lib/router/utils/app-paths");
|
||||
const _routerservercontext = require("../lib/router-utils/router-server-context");
|
||||
const _decodepathparams = require("../lib/router-utils/decode-path-params");
|
||||
const _removetrailingslash = require("../../shared/lib/router/utils/remove-trailing-slash");
|
||||
const _isinterceptionrouterewrite = require("../../lib/is-interception-route-rewrite");
|
||||
function _interop_require_default(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
const dynamicImportEsmDefault = (id)=>import(/* webpackIgnore: true */ /* turbopackIgnore: true */ id).then((mod)=>mod.default || mod);
|
||||
class RouteModule {
|
||||
constructor({ userland, definition, distDir, relativeProjectDir }){
|
||||
this.userland = userland;
|
||||
this.definition = definition;
|
||||
this.isDev = !!process.env.__NEXT_DEV_SERVER;
|
||||
this.distDir = distDir;
|
||||
this.relativeProjectDir = relativeProjectDir;
|
||||
}
|
||||
getRouterServerContext(req) {
|
||||
var _routerServerGlobal_RouterServerContextSymbol;
|
||||
const hostname = (0, _requestmeta.getRequestMeta)(req, 'hostname');
|
||||
const revalidate = (0, _requestmeta.getRequestMeta)(req, 'revalidate');
|
||||
const render404 = (0, _requestmeta.getRequestMeta)(req, 'render404');
|
||||
const relativeProjectDir = (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir;
|
||||
const routerServerContext = (_routerServerGlobal_RouterServerContextSymbol = _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol]) == null ? void 0 : _routerServerGlobal_RouterServerContextSymbol[relativeProjectDir];
|
||||
return {
|
||||
...routerServerContext,
|
||||
...hostname !== undefined ? {
|
||||
hostname
|
||||
} : {},
|
||||
...revalidate !== undefined ? {
|
||||
revalidate
|
||||
} : {},
|
||||
...render404 !== undefined ? {
|
||||
render404
|
||||
} : {}
|
||||
};
|
||||
}
|
||||
normalizeUrl(_req, _parsedUrl) {}
|
||||
async instrumentationOnRequestError(req, ...args) {
|
||||
if (process.env.NEXT_RUNTIME === 'edge') {
|
||||
const { getEdgeInstrumentationModule } = await import('../web/globals');
|
||||
const instrumentation = await getEdgeInstrumentationModule();
|
||||
if (instrumentation) {
|
||||
await (instrumentation.onRequestError == null ? void 0 : instrumentation.onRequestError.call(instrumentation, ...args));
|
||||
}
|
||||
} else {
|
||||
const { join } = require('node:path');
|
||||
const absoluteProjectDir = join(/* turbopackIgnore: true */ process.cwd(), (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir);
|
||||
const { instrumentationOnRequestError } = await import('../lib/router-utils/instrumentation-globals.external.js');
|
||||
return instrumentationOnRequestError(absoluteProjectDir, this.distDir, ...args);
|
||||
}
|
||||
}
|
||||
loadManifests(srcPage, projectDir) {
|
||||
let result;
|
||||
if (process.env.NEXT_RUNTIME === 'edge') {
|
||||
var _self___RSC_MANIFEST;
|
||||
const { getEdgePreviewProps } = require('../web/get-edge-preview-props');
|
||||
const maybeJSONParse = (str)=>str ? JSON.parse(str) : undefined;
|
||||
result = {
|
||||
buildId: process.env.__NEXT_BUILD_ID || '',
|
||||
buildManifest: self.__BUILD_MANIFEST,
|
||||
fallbackBuildManifest: {},
|
||||
reactLoadableManifest: maybeJSONParse(self.__REACT_LOADABLE_MANIFEST),
|
||||
nextFontManifest: maybeJSONParse(self.__NEXT_FONT_MANIFEST),
|
||||
prerenderManifest: {
|
||||
routes: {},
|
||||
dynamicRoutes: {},
|
||||
notFoundRoutes: [],
|
||||
version: 4,
|
||||
preview: getEdgePreviewProps()
|
||||
},
|
||||
routesManifest: {
|
||||
version: 4,
|
||||
caseSensitive: Boolean(process.env.__NEXT_CASE_SENSITIVE_ROUTES),
|
||||
basePath: process.env.__NEXT_BASE_PATH || '',
|
||||
rewrites: process.env.__NEXT_REWRITES || {
|
||||
beforeFiles: [],
|
||||
afterFiles: [],
|
||||
fallback: []
|
||||
},
|
||||
redirects: [],
|
||||
headers: [],
|
||||
onMatchHeaders: [],
|
||||
i18n: process.env.__NEXT_I18N_CONFIG || undefined,
|
||||
skipProxyUrlNormalize: Boolean(process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE)
|
||||
},
|
||||
serverFilesManifest: self.__SERVER_FILES_MANIFEST,
|
||||
clientReferenceManifest: (_self___RSC_MANIFEST = self.__RSC_MANIFEST) == null ? void 0 : _self___RSC_MANIFEST[srcPage],
|
||||
serverActionsManifest: maybeJSONParse(self.__RSC_SERVER_MANIFEST),
|
||||
subresourceIntegrityManifest: maybeJSONParse(self.__SUBRESOURCE_INTEGRITY_MANIFEST),
|
||||
dynamicCssManifest: maybeJSONParse(self.__DYNAMIC_CSS_MANIFEST),
|
||||
interceptionRoutePatterns: (maybeJSONParse(self.__INTERCEPTION_ROUTE_REWRITE_MANIFEST) ?? []).map((rewrite)=>new RegExp(rewrite.regex))
|
||||
};
|
||||
} else {
|
||||
var _clientReferenceManifest___RSC_MANIFEST;
|
||||
if (!projectDir) {
|
||||
throw Object.defineProperty(new Error('Invariant: projectDir is required for node runtime'), "__NEXT_ERROR_CODE", {
|
||||
value: "E718",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
const { loadManifestFromRelativePath } = require('../load-manifest.external');
|
||||
const normalizedPagePath = (0, _normalizepagepath.normalizePagePath)(srcPage);
|
||||
const router = this.definition.kind === _routekind.RouteKind.PAGES || this.definition.kind === _routekind.RouteKind.PAGES_API ? 'pages' : 'app';
|
||||
const [routesManifest, prerenderManifest, buildManifest, fallbackBuildManifest, reactLoadableManifest, nextFontManifest, clientReferenceManifest, serverActionsManifest, subresourceIntegrityManifest, serverFilesManifest, buildId, dynamicCssManifest] = [
|
||||
loadManifestFromRelativePath({
|
||||
projectDir,
|
||||
distDir: this.distDir,
|
||||
manifest: _constants.ROUTES_MANIFEST,
|
||||
shouldCache: !this.isDev
|
||||
}),
|
||||
loadManifestFromRelativePath({
|
||||
projectDir,
|
||||
distDir: this.distDir,
|
||||
manifest: _constants.PRERENDER_MANIFEST,
|
||||
shouldCache: !this.isDev
|
||||
}),
|
||||
loadManifestFromRelativePath({
|
||||
projectDir,
|
||||
distDir: this.distDir,
|
||||
manifest: _constants.BUILD_MANIFEST,
|
||||
shouldCache: !this.isDev
|
||||
}),
|
||||
srcPage === '/_error' ? loadManifestFromRelativePath({
|
||||
projectDir,
|
||||
distDir: this.distDir,
|
||||
manifest: `fallback-${_constants.BUILD_MANIFEST}`,
|
||||
shouldCache: !this.isDev,
|
||||
handleMissing: true
|
||||
}) : {},
|
||||
loadManifestFromRelativePath({
|
||||
projectDir,
|
||||
distDir: this.distDir,
|
||||
manifest: process.env.TURBOPACK ? `server/${router === 'app' ? 'app' : 'pages'}${normalizedPagePath}/${_constants.REACT_LOADABLE_MANIFEST}` : _constants.REACT_LOADABLE_MANIFEST,
|
||||
handleMissing: true,
|
||||
shouldCache: !this.isDev
|
||||
}),
|
||||
loadManifestFromRelativePath({
|
||||
projectDir,
|
||||
distDir: this.distDir,
|
||||
manifest: `server/${_constants.NEXT_FONT_MANIFEST}.json`,
|
||||
shouldCache: !this.isDev
|
||||
}),
|
||||
router === 'app' && !(0, _ismetadataroute.isStaticMetadataRoute)(srcPage) ? loadManifestFromRelativePath({
|
||||
distDir: this.distDir,
|
||||
projectDir,
|
||||
useEval: true,
|
||||
handleMissing: true,
|
||||
manifest: `server/app${srcPage.replace(/%5F/g, '_') + '_' + _constants.CLIENT_REFERENCE_MANIFEST}.js`,
|
||||
shouldCache: !this.isDev
|
||||
}) : undefined,
|
||||
router === 'app' ? loadManifestFromRelativePath({
|
||||
distDir: this.distDir,
|
||||
projectDir,
|
||||
manifest: `server/${_constants.SERVER_REFERENCE_MANIFEST}.json`,
|
||||
handleMissing: true,
|
||||
shouldCache: !this.isDev
|
||||
}) : {},
|
||||
loadManifestFromRelativePath({
|
||||
projectDir,
|
||||
distDir: this.distDir,
|
||||
manifest: `server/${_constants.SUBRESOURCE_INTEGRITY_MANIFEST}.json`,
|
||||
handleMissing: true,
|
||||
shouldCache: !this.isDev
|
||||
}),
|
||||
this.isDev ? undefined : loadManifestFromRelativePath({
|
||||
projectDir,
|
||||
distDir: this.distDir,
|
||||
shouldCache: true,
|
||||
manifest: `${_constants.SERVER_FILES_MANIFEST}.json`
|
||||
}),
|
||||
this.isDev ? 'development' : loadManifestFromRelativePath({
|
||||
projectDir,
|
||||
distDir: this.distDir,
|
||||
manifest: _constants.BUILD_ID_FILE,
|
||||
skipParse: true,
|
||||
shouldCache: true
|
||||
}),
|
||||
loadManifestFromRelativePath({
|
||||
projectDir,
|
||||
distDir: this.distDir,
|
||||
manifest: _constants.DYNAMIC_CSS_MANIFEST,
|
||||
shouldCache: !this.isDev,
|
||||
handleMissing: true
|
||||
})
|
||||
];
|
||||
result = {
|
||||
buildId,
|
||||
buildManifest,
|
||||
fallbackBuildManifest,
|
||||
routesManifest,
|
||||
nextFontManifest,
|
||||
prerenderManifest,
|
||||
serverFilesManifest,
|
||||
reactLoadableManifest,
|
||||
clientReferenceManifest: clientReferenceManifest == null ? void 0 : (_clientReferenceManifest___RSC_MANIFEST = clientReferenceManifest.__RSC_MANIFEST) == null ? void 0 : _clientReferenceManifest___RSC_MANIFEST[srcPage.replace(/%5F/g, '_')],
|
||||
serverActionsManifest,
|
||||
subresourceIntegrityManifest,
|
||||
dynamicCssManifest,
|
||||
interceptionRoutePatterns: routesManifest.rewrites.beforeFiles.filter(_isinterceptionrouterewrite.isInterceptionRouteRewrite).map((rewrite)=>new RegExp(rewrite.regex))
|
||||
};
|
||||
}
|
||||
return result;
|
||||
}
|
||||
async loadCustomCacheHandlers(req, nextConfig) {
|
||||
if (process.env.NEXT_RUNTIME !== 'edge') {
|
||||
const { cacheMaxMemorySize, cacheHandlers } = nextConfig;
|
||||
if (!cacheHandlers) return;
|
||||
// If we've already initialized the cache handlers interface, don't do it
|
||||
// again.
|
||||
if (!(0, _handlers.initializeCacheHandlers)(cacheMaxMemorySize)) return;
|
||||
for (const [kind, handler] of Object.entries(cacheHandlers)){
|
||||
if (!handler) continue;
|
||||
const { formatDynamicImportPath } = require('../../lib/format-dynamic-import-path');
|
||||
const { join } = require('node:path');
|
||||
const absoluteProjectDir = join(/* turbopackIgnore: true */ process.cwd(), (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir);
|
||||
(0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault(formatDynamicImportPath(`${absoluteProjectDir}/${this.distDir}`, handler))));
|
||||
}
|
||||
}
|
||||
}
|
||||
async getIncrementalCache(req, nextConfig, prerenderManifest, isMinimalMode) {
|
||||
if (process.env.NEXT_RUNTIME === 'edge') {
|
||||
return globalThis.__incrementalCache;
|
||||
} else {
|
||||
let CacheHandler;
|
||||
const { cacheHandler } = nextConfig;
|
||||
if (cacheHandler) {
|
||||
const { formatDynamicImportPath } = require('../../lib/format-dynamic-import-path');
|
||||
CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault(formatDynamicImportPath(this.distDir, cacheHandler)));
|
||||
}
|
||||
const { join } = require('node:path');
|
||||
const projectDir = join(/* turbopackIgnore: true */ process.cwd(), (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir);
|
||||
await this.loadCustomCacheHandlers(req, nextConfig);
|
||||
// incremental-cache is request specific
|
||||
// although can have shared caches in module scope
|
||||
// per-cache handler
|
||||
const incrementalCache = new _incrementalcache.IncrementalCache({
|
||||
fs: require('../lib/node-fs-methods').nodeFs,
|
||||
dev: this.isDev,
|
||||
requestHeaders: req.headers,
|
||||
allowedRevalidateHeaderKeys: nextConfig.experimental.allowedRevalidateHeaderKeys,
|
||||
minimalMode: isMinimalMode,
|
||||
serverDistDir: `${projectDir}/${this.distDir}/server`,
|
||||
fetchCacheKeyPrefix: nextConfig.experimental.fetchCacheKeyPrefix,
|
||||
maxMemoryCacheSize: nextConfig.cacheMaxMemorySize,
|
||||
flushToDisk: !isMinimalMode && nextConfig.experimental.isrFlushToDisk,
|
||||
getPrerenderManifest: ()=>prerenderManifest,
|
||||
CurCacheHandler: CacheHandler
|
||||
});
|
||||
globalThis.__incrementalCache = incrementalCache;
|
||||
return incrementalCache;
|
||||
}
|
||||
}
|
||||
async onRequestError(req, err, errorContext, silenceLog, routerServerContext) {
|
||||
if (!silenceLog) {
|
||||
if (routerServerContext == null ? void 0 : routerServerContext.logErrorWithOriginalStack) {
|
||||
routerServerContext.logErrorWithOriginalStack(err, 'app-dir');
|
||||
} else {
|
||||
console.error(err);
|
||||
}
|
||||
}
|
||||
await this.instrumentationOnRequestError(req, err, {
|
||||
path: req.url || '/',
|
||||
headers: req.headers,
|
||||
method: req.method || 'GET'
|
||||
}, errorContext);
|
||||
}
|
||||
/** A more lightweight version of `prepare()` for only retrieving the config on edge */ getNextConfigEdge(req) {
|
||||
var _nextConfig_experimental;
|
||||
if (process.env.NEXT_RUNTIME !== 'edge') {
|
||||
throw Object.defineProperty(new Error('Invariant: getNextConfigEdge must only be called in edge runtime'), "__NEXT_ERROR_CODE", {
|
||||
value: "E968",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
let serverFilesManifest = self.__SERVER_FILES_MANIFEST;
|
||||
const routerServerContext = this.getRouterServerContext(req);
|
||||
const nextConfig = (routerServerContext == null ? void 0 : routerServerContext.nextConfig) || (serverFilesManifest == null ? void 0 : serverFilesManifest.config);
|
||||
if (!nextConfig) {
|
||||
throw Object.defineProperty(new Error("Invariant: nextConfig couldn't be loaded"), "__NEXT_ERROR_CODE", {
|
||||
value: "E969",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
let deploymentId;
|
||||
if ((_nextConfig_experimental = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental.runtimeServerDeploymentId) {
|
||||
if (!process.env.NEXT_DEPLOYMENT_ID) {
|
||||
throw Object.defineProperty(new Error('process.env.NEXT_DEPLOYMENT_ID is missing but runtimeServerDeploymentId is enabled'), "__NEXT_ERROR_CODE", {
|
||||
value: "E970",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
deploymentId = process.env.NEXT_DEPLOYMENT_ID;
|
||||
} else {
|
||||
deploymentId = nextConfig.deploymentId || '';
|
||||
}
|
||||
return {
|
||||
nextConfig,
|
||||
deploymentId
|
||||
};
|
||||
}
|
||||
async prepare(req, res, { srcPage, multiZoneDraftMode }) {
|
||||
var _req_headers_xforwardedproto, _nextConfig_experimental;
|
||||
let absoluteProjectDir;
|
||||
// edge runtime handles loading instrumentation at the edge adapter level
|
||||
if (process.env.NEXT_RUNTIME !== 'edge') {
|
||||
if (res) {
|
||||
(0, _patchsetheader.patchSetHeaderWithCookieSupport)(req, res);
|
||||
}
|
||||
const { join, relative } = require('node:path');
|
||||
absoluteProjectDir = join(/* turbopackIgnore: true */ process.cwd(), (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir);
|
||||
const absoluteDistDir = (0, _requestmeta.getRequestMeta)(req, 'distDir');
|
||||
if (absoluteDistDir) {
|
||||
this.distDir = relative(absoluteProjectDir, absoluteDistDir);
|
||||
}
|
||||
const { ensureInstrumentationRegistered } = await import('../lib/router-utils/instrumentation-globals.external.js');
|
||||
// ensure instrumentation is registered and pass
|
||||
// onRequestError below
|
||||
ensureInstrumentationRegistered(absoluteProjectDir, this.distDir);
|
||||
}
|
||||
const manifests = this.loadManifests(srcPage, absoluteProjectDir);
|
||||
const { routesManifest, prerenderManifest, serverFilesManifest } = manifests;
|
||||
const { basePath, i18n, rewrites } = routesManifest;
|
||||
const routerServerContext = this.getRouterServerContext(req);
|
||||
const nextConfig = (routerServerContext == null ? void 0 : routerServerContext.nextConfig) || (serverFilesManifest == null ? void 0 : serverFilesManifest.config);
|
||||
// Injected in base-server.ts
|
||||
const protocol = ((_req_headers_xforwardedproto = req.headers['x-forwarded-proto']) == null ? void 0 : _req_headers_xforwardedproto.includes('https')) ? 'https' : 'http';
|
||||
// When there are hostname and port we build an absolute URL
|
||||
if (!(0, _requestmeta.getRequestMeta)(req, 'initURL')) {
|
||||
const initUrl = (serverFilesManifest == null ? void 0 : serverFilesManifest.config.experimental.trustHostHeader) ? `${protocol}://${req.headers.host || 'localhost'}${req.url}` : `${protocol}://${(routerServerContext == null ? void 0 : routerServerContext.hostname) || 'localhost'}${req.url}`;
|
||||
(0, _requestmeta.addRequestMeta)(req, 'initURL', initUrl);
|
||||
(0, _requestmeta.addRequestMeta)(req, 'initProtocol', protocol);
|
||||
}
|
||||
if (basePath) {
|
||||
req.url = (0, _removepathprefix.removePathPrefix)(req.url || '/', basePath);
|
||||
}
|
||||
const parsedUrl = (0, _url.parseReqUrl)(req.url || '/');
|
||||
(0, _requestmeta.addRequestMeta)(req, 'initQuery', {
|
||||
...parsedUrl == null ? void 0 : parsedUrl.query
|
||||
});
|
||||
// if we couldn't parse the URL we can't continue
|
||||
if (!parsedUrl) {
|
||||
return;
|
||||
}
|
||||
let isNextDataRequest = false;
|
||||
if ((0, _pathhasprefix.pathHasPrefix)(parsedUrl.pathname || '/', '/_next/data')) {
|
||||
isNextDataRequest = true;
|
||||
parsedUrl.pathname = (0, _normalizedatapath.normalizeDataPath)(parsedUrl.pathname || '/');
|
||||
}
|
||||
this.normalizeUrl(req, parsedUrl);
|
||||
let originalPathname = parsedUrl.pathname || '/';
|
||||
const originalQuery = {
|
||||
...parsedUrl.query
|
||||
};
|
||||
const pageIsDynamic = (0, _utils.isDynamicRoute)(srcPage);
|
||||
let localeResult;
|
||||
let detectedLocale;
|
||||
if (i18n) {
|
||||
localeResult = (0, _normalizelocalepath.normalizeLocalePath)(parsedUrl.pathname || '/', i18n.locales);
|
||||
if (localeResult.detectedLocale) {
|
||||
req.url = `${localeResult.pathname}${parsedUrl.search}`;
|
||||
originalPathname = localeResult.pathname;
|
||||
if (!detectedLocale) {
|
||||
detectedLocale = localeResult.detectedLocale;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Normalize the page path for route matching. The srcPage contains the
|
||||
// internal page path (e.g., /app/[slug]/page), but route matchers expect
|
||||
// the pathname format (e.g., /app/[slug]).
|
||||
const normalizedSrcPage = (0, _apppaths.normalizeAppPath)(srcPage);
|
||||
const serverUtils = (0, _serverutils.getServerUtils)({
|
||||
page: normalizedSrcPage,
|
||||
i18n,
|
||||
basePath,
|
||||
rewrites,
|
||||
pageIsDynamic,
|
||||
trailingSlash: process.env.__NEXT_TRAILING_SLASH,
|
||||
caseSensitive: Boolean(routesManifest.caseSensitive)
|
||||
});
|
||||
const domainLocale = (0, _detectdomainlocale.detectDomainLocale)(i18n == null ? void 0 : i18n.domains, (0, _gethostname.getHostname)(parsedUrl, req.headers), detectedLocale);
|
||||
if (Boolean(domainLocale)) {
|
||||
(0, _requestmeta.addRequestMeta)(req, 'isLocaleDomain', Boolean(domainLocale));
|
||||
}
|
||||
const defaultLocale = (0, _requestmeta.getRequestMeta)(req, 'defaultLocale') || (domainLocale == null ? void 0 : domainLocale.defaultLocale) || (i18n == null ? void 0 : i18n.defaultLocale);
|
||||
// Ensure parsedUrl.pathname includes locale before processing
|
||||
// rewrites or they won't match correctly.
|
||||
if (defaultLocale && !detectedLocale) {
|
||||
parsedUrl.pathname = `/${defaultLocale}${parsedUrl.pathname === '/' ? '' : parsedUrl.pathname}`;
|
||||
}
|
||||
const locale = (0, _requestmeta.getRequestMeta)(req, 'locale') || detectedLocale || defaultLocale;
|
||||
// we apply rewrites against cloned URL so that we don't
|
||||
// modify the original with the rewrite destination
|
||||
const { rewriteParams, rewrittenParsedUrl } = serverUtils.handleRewrites(req, parsedUrl);
|
||||
const rewriteParamKeys = Object.keys(rewriteParams);
|
||||
Object.assign(parsedUrl.query, rewrittenParsedUrl.query);
|
||||
// after processing rewrites we want to remove locale
|
||||
// from parsedUrl pathname
|
||||
if (i18n) {
|
||||
parsedUrl.pathname = (0, _normalizelocalepath.normalizeLocalePath)(parsedUrl.pathname || '/', i18n.locales).pathname;
|
||||
rewrittenParsedUrl.pathname = (0, _normalizelocalepath.normalizeLocalePath)(rewrittenParsedUrl.pathname || '/', i18n.locales).pathname;
|
||||
}
|
||||
let params = (0, _requestmeta.getRequestMeta)(req, 'params');
|
||||
// attempt parsing from pathname
|
||||
if (!params && serverUtils.dynamicRouteMatcher) {
|
||||
const paramsMatch = serverUtils.dynamicRouteMatcher((0, _normalizedatapath.normalizeDataPath)((rewrittenParsedUrl == null ? void 0 : rewrittenParsedUrl.pathname) || parsedUrl.pathname || '/'));
|
||||
const paramsResult = serverUtils.normalizeDynamicRouteParams(paramsMatch || {}, true);
|
||||
if (paramsResult.hasValidParams) {
|
||||
params = paramsResult.params;
|
||||
}
|
||||
}
|
||||
// Local "next start" expects the routing parsed query values
|
||||
// to not be present in the URL although when deployed proxies
|
||||
// will add query values from resolving the routes to pass to function.
|
||||
// TODO: do we want to change expectations for "next start"
|
||||
// to include these query values in the URL which affects asPath
|
||||
// but would match deployed behavior, e.g. a rewrite from middleware
|
||||
// that adds a query param would be in asPath as query but locally
|
||||
// it won't be in the asPath but still available in the query object
|
||||
const query = (0, _requestmeta.getRequestMeta)(req, 'query') || {
|
||||
...parsedUrl.query
|
||||
};
|
||||
const routeParamKeys = new Set();
|
||||
const combinedParamKeys = [];
|
||||
// We don't include rewriteParamKeys in the combinedParamKeys
|
||||
// for app router since the searchParams is populated from the
|
||||
// URL so we don't want to strip the rewrite params from the URL
|
||||
// so that searchParams can include them.
|
||||
if (this.definition.kind === _routekind.RouteKind.PAGES || this.definition.kind === _routekind.RouteKind.PAGES_API) {
|
||||
for (const key of [
|
||||
...rewriteParamKeys,
|
||||
...Object.keys(serverUtils.defaultRouteMatches || {})
|
||||
]){
|
||||
// We only want to filter rewrite param keys from the URL
|
||||
// if they are matches from the URL e.g. the key/value matches
|
||||
// before and after applying the rewrites /:path for /hello and
|
||||
// { path: 'hello' } but not for { path: 'another' } and /hello
|
||||
// TODO: we should prefix rewrite param keys the same as we do
|
||||
// for dynamic routes so we can identify them properly
|
||||
const originalValue = Array.isArray(originalQuery[key]) ? originalQuery[key].join('') : originalQuery[key];
|
||||
const queryValue = Array.isArray(query[key]) ? query[key].join('') : query[key];
|
||||
if (!(key in originalQuery) || originalValue === queryValue) {
|
||||
combinedParamKeys.push(key);
|
||||
}
|
||||
}
|
||||
}
|
||||
serverUtils.normalizeCdnUrl(req, combinedParamKeys);
|
||||
// When Next is not hosted in a single process, upstream proxies will add query values for route params that were used to match the route.
|
||||
// Outside of that environment, there is no reason to do any normalization to honor those query values.
|
||||
if (!(routerServerContext == null ? void 0 : routerServerContext.isWrappedByNextServer)) {
|
||||
serverUtils.normalizeQueryParams(query, routeParamKeys);
|
||||
} else {
|
||||
serverUtils.filterInternalQuery(query, []);
|
||||
}
|
||||
serverUtils.filterInternalQuery(originalQuery, combinedParamKeys);
|
||||
if (pageIsDynamic) {
|
||||
const queryResult = serverUtils.normalizeDynamicRouteParams(query, true);
|
||||
const paramsResult = serverUtils.normalizeDynamicRouteParams(params || {}, true);
|
||||
let paramsToInterpolate;
|
||||
if (// if both query and params are valid but one
|
||||
// provided more information and the query params
|
||||
// were nxtP prefixed rely on that one
|
||||
query && params && paramsResult.hasValidParams && queryResult.hasValidParams && routeParamKeys.size > 0 && Object.keys(paramsResult.params).length <= Object.keys(queryResult.params).length) {
|
||||
paramsToInterpolate = queryResult.params;
|
||||
params = Object.assign(queryResult.params);
|
||||
} else {
|
||||
paramsToInterpolate = paramsResult.hasValidParams && params ? params : queryResult.hasValidParams ? query : {};
|
||||
}
|
||||
req.url = serverUtils.interpolateDynamicPath(req.url || '/', paramsToInterpolate);
|
||||
parsedUrl.pathname = serverUtils.interpolateDynamicPath(parsedUrl.pathname || '/', paramsToInterpolate);
|
||||
originalPathname = serverUtils.interpolateDynamicPath(originalPathname, paramsToInterpolate);
|
||||
// try pulling from query if valid
|
||||
if (!params) {
|
||||
if (queryResult.hasValidParams) {
|
||||
params = Object.assign({}, queryResult.params);
|
||||
// If we pulled from query remove it so it's
|
||||
// only in params
|
||||
for(const key in serverUtils.defaultRouteMatches){
|
||||
delete query[key];
|
||||
}
|
||||
} else {
|
||||
// use final params from URL matching
|
||||
const paramsMatch = serverUtils.dynamicRouteMatcher == null ? void 0 : serverUtils.dynamicRouteMatcher.call(serverUtils, (0, _normalizedatapath.normalizeDataPath)((localeResult == null ? void 0 : localeResult.pathname) || parsedUrl.pathname || '/'));
|
||||
// we don't normalize these as they are allowed to be
|
||||
// the literal slug matches here e.g. /blog/[slug]
|
||||
// actually being requested
|
||||
if (paramsMatch) {
|
||||
params = Object.assign({}, paramsMatch);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Remove any normalized params from the query if they
|
||||
// weren't present as non-prefixed query key e.g.
|
||||
// ?search=1&nxtPsearch=hello we don't delete search
|
||||
for (const key of routeParamKeys){
|
||||
if (!(key in originalQuery)) {
|
||||
delete query[key];
|
||||
// handle the case where there's collision and we
|
||||
// normalized nxtPid=123 -> id=123 but user also
|
||||
// sends id=456 as separate key
|
||||
} else if (originalQuery[key] && query[key] && originalQuery[key] !== query[key]) {
|
||||
query[key] = originalQuery[key];
|
||||
}
|
||||
}
|
||||
const { isOnDemandRevalidate, revalidateOnlyGenerated } = (0, _apiutils.checkIsOnDemandRevalidate)(req, prerenderManifest.preview);
|
||||
let isDraftMode = false;
|
||||
let previewData;
|
||||
// preview data relies on non-edge utils
|
||||
if (process.env.NEXT_RUNTIME !== 'edge' && res) {
|
||||
const { tryGetPreviewData } = require('../api-utils/node/try-get-preview-data');
|
||||
previewData = tryGetPreviewData(req, res, prerenderManifest.preview, Boolean(multiZoneDraftMode));
|
||||
isDraftMode = previewData !== false;
|
||||
}
|
||||
if (!nextConfig) {
|
||||
throw Object.defineProperty(new Error("Invariant: nextConfig couldn't be loaded"), "__NEXT_ERROR_CODE", {
|
||||
value: "E969",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
if (process.env.NEXT_RUNTIME !== 'edge') {
|
||||
const { installProcessErrorHandlers } = require('../node-environment-extensions/process-error-handlers');
|
||||
installProcessErrorHandlers(Boolean(nextConfig.experimental.removeUncaughtErrorAndRejectionListeners));
|
||||
}
|
||||
let resolvedPathname = normalizedSrcPage;
|
||||
if ((0, _utils.isDynamicRoute)(resolvedPathname) && params) {
|
||||
resolvedPathname = serverUtils.interpolateDynamicPath(resolvedPathname, params);
|
||||
}
|
||||
if (resolvedPathname === '/index') {
|
||||
resolvedPathname = '/';
|
||||
}
|
||||
if (res && Boolean(req.headers['x-nextjs-data']) && (!res.statusCode || res.statusCode === 200)) {
|
||||
res.setHeader('x-nextjs-matched-path', (0, _removetrailingslash.removeTrailingSlash)(`${locale ? `/${locale}` : ''}${normalizedSrcPage}`));
|
||||
}
|
||||
const encodedResolvedPathname = resolvedPathname;
|
||||
// we decode for cache key/manifest usage encoded is
|
||||
// for URL building
|
||||
try {
|
||||
resolvedPathname = (0, _decodepathparams.decodePathParams)(resolvedPathname);
|
||||
} catch (_) {}
|
||||
resolvedPathname = (0, _removetrailingslash.removeTrailingSlash)(resolvedPathname);
|
||||
(0, _requestmeta.addRequestMeta)(req, 'resolvedPathname', resolvedPathname);
|
||||
let deploymentId;
|
||||
if ((_nextConfig_experimental = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental.runtimeServerDeploymentId) {
|
||||
if (!process.env.NEXT_DEPLOYMENT_ID) {
|
||||
throw Object.defineProperty(new Error('process.env.NEXT_DEPLOYMENT_ID is missing but runtimeServerDeploymentId is enabled'), "__NEXT_ERROR_CODE", {
|
||||
value: "E970",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
deploymentId = process.env.NEXT_DEPLOYMENT_ID;
|
||||
} else {
|
||||
deploymentId = nextConfig.deploymentId || '';
|
||||
}
|
||||
return {
|
||||
query,
|
||||
originalQuery,
|
||||
originalPathname,
|
||||
params,
|
||||
parsedUrl,
|
||||
locale,
|
||||
isNextDataRequest,
|
||||
locales: i18n == null ? void 0 : i18n.locales,
|
||||
defaultLocale,
|
||||
isDraftMode,
|
||||
previewData,
|
||||
pageIsDynamic,
|
||||
resolvedPathname,
|
||||
encodedResolvedPathname,
|
||||
isOnDemandRevalidate,
|
||||
revalidateOnlyGenerated,
|
||||
...manifests,
|
||||
// loadManifest returns a readonly object, but we don't want to propagate that throughout the
|
||||
// whole codebase (for now)
|
||||
nextConfig: nextConfig,
|
||||
routerServerContext,
|
||||
deploymentId,
|
||||
clientAssetToken: nextConfig.experimental.immutableAssetToken || deploymentId
|
||||
};
|
||||
}
|
||||
getResponseCache(req) {
|
||||
if (!this.responseCache) {
|
||||
const minimalMode = (0, _requestmeta.getRequestMeta)(req, 'minimalMode') ?? false;
|
||||
this.responseCache = new _responsecache.default(minimalMode);
|
||||
}
|
||||
return this.responseCache;
|
||||
}
|
||||
async handleResponse({ req, nextConfig, cacheKey, routeKind, isFallback, prerenderManifest, isRoutePPREnabled, isOnDemandRevalidate, revalidateOnlyGenerated, responseGenerator, waitUntil, isMinimalMode }) {
|
||||
const responseCache = this.getResponseCache(req);
|
||||
const cacheEntry = await responseCache.get(cacheKey, responseGenerator, {
|
||||
routeKind,
|
||||
isFallback,
|
||||
isRoutePPREnabled,
|
||||
isOnDemandRevalidate,
|
||||
isPrefetch: req.headers.purpose === 'prefetch',
|
||||
// Use x-invocation-id header to scope the in-memory cache to a single
|
||||
// revalidation request in minimal mode.
|
||||
invocationID: req.headers['x-invocation-id'],
|
||||
incrementalCache: await this.getIncrementalCache(req, nextConfig, prerenderManifest, isMinimalMode),
|
||||
waitUntil
|
||||
});
|
||||
if (!cacheEntry) {
|
||||
if (cacheKey && // revalidate only generated can bail even if cacheKey is provided
|
||||
!(isOnDemandRevalidate && revalidateOnlyGenerated)) {
|
||||
// A cache entry might not be generated if a response is written
|
||||
// in `getInitialProps` or `getServerSideProps`, but those shouldn't
|
||||
// have a cache key. If we do have a cache key but we don't end up
|
||||
// with a cache entry, then either Next.js or the application has a
|
||||
// bug that needs fixing.
|
||||
throw Object.defineProperty(new Error('invariant: cache entry required but not generated'), "__NEXT_ERROR_CODE", {
|
||||
value: "E62",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
return cacheEntry;
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=route-module.js.map
|
||||
Reference in New Issue
Block a user