Spaces:
Running
Running
File size: 11,863 Bytes
979bf48 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 | "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "headers", {
enumerable: true,
get: function() {
return headers;
}
});
const _headers = require("../web/spec-extension/adapters/headers");
const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
const _dynamicrendering = require("../app-render/dynamic-rendering");
const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
const _dynamicrenderingutils = require("../dynamic-rendering-utils");
const _creatededupedbycallsiteservererrorlogger = require("../create-deduped-by-callsite-server-error-logger");
const _utils = require("./utils");
const _invarianterror = require("../../shared/lib/invariant-error");
const _stagedrendering = require("../app-render/staged-rendering");
function headers() {
const callingExpression = 'headers';
const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
if (workStore) {
if (workUnitStore && workUnitStore.phase === 'after' && !(0, _utils.isRequestAPICallableInsideAfter)()) {
throw Object.defineProperty(new Error(`Route ${workStore.route} used \`headers()\` inside \`after()\`. This is not supported. If you need this data inside an \`after()\` callback, use \`headers()\` outside of the callback. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
value: "E839",
enumerable: false,
configurable: true
});
}
if (workStore.forceStatic) {
// When using forceStatic we override all other logic and always just return an empty
// headers object without tracking
const underlyingHeaders = _headers.HeadersAdapter.seal(new Headers({}));
return makeUntrackedHeaders(underlyingHeaders);
}
if (workUnitStore) {
switch(workUnitStore.type){
case 'cache':
{
const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`headers()\` inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`headers()\` 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: "E833",
enumerable: false,
configurable: true
});
Error.captureStackTrace(error, headers);
workStore.invalidDynamicUsageError ??= error;
throw error;
}
case 'unstable-cache':
throw Object.defineProperty(new Error(`Route ${workStore.route} used \`headers()\` 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 \`headers()\` 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: "E838",
enumerable: false,
configurable: true
});
case 'prerender':
case 'prerender-client':
case 'private-cache':
case 'prerender-runtime':
case 'prerender-ppr':
case 'prerender-legacy':
case 'request':
break;
default:
workUnitStore;
}
}
if (workStore.dynamicShouldError) {
throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`headers()\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
value: "E828",
enumerable: false,
configurable: true
});
}
if (workUnitStore) {
switch(workUnitStore.type){
case 'prerender':
return makeHangingHeaders(workStore, workUnitStore);
case 'prerender-client':
const exportName = '`headers`';
throw Object.defineProperty(new _invarianterror.InvariantError(`${exportName} must not be used within a client component. Next.js should be preventing ${exportName} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
value: "E693",
enumerable: false,
configurable: true
});
case 'prerender-ppr':
// PPR Prerender (no cacheComponents)
// We are prerendering with PPR. We need track dynamic access here eagerly
// to keep continuity with how headers has worked in PPR without cacheComponents.
// TODO consider switching the semantic to throw on property access instead
return (0, _dynamicrendering.postponeWithTracking)(workStore.route, callingExpression, workUnitStore.dynamicTracking);
case 'prerender-legacy':
// Legacy Prerender
// We are in a legacy static generation mode while prerendering
// We track dynamic access here so we don't need to wrap the headers in
// individual property access tracking.
return (0, _dynamicrendering.throwToInterruptStaticGeneration)(callingExpression, workStore, workUnitStore);
case 'prerender-runtime':
return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, makeUntrackedHeaders(workUnitStore.headers));
case 'private-cache':
// Private caches are delayed until the runtime stage in use-cache-wrapper,
// so we don't need an additional delay here.
return makeUntrackedHeaders(workUnitStore.headers);
case 'request':
(0, _dynamicrendering.trackDynamicDataInDynamicRender)(workUnitStore);
if (process.env.NODE_ENV === 'development') {
// Semantically we only need the dev tracking when running in `next dev`
// but since you would never use next dev with production NODE_ENV we use this
// as a proxy so we can statically exclude this code from production builds.
return makeUntrackedHeadersWithDevWarnings(workUnitStore.headers, workStore == null ? void 0 : workStore.route, workUnitStore);
} else {
return makeUntrackedHeaders(workUnitStore.headers);
}
break;
default:
workUnitStore;
}
}
}
// If we end up here, there was no work store or work unit store present.
(0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
}
const CachedHeaders = new WeakMap();
function makeHangingHeaders(workStore, prerenderStore) {
const cachedHeaders = CachedHeaders.get(prerenderStore);
if (cachedHeaders) {
return cachedHeaders;
}
const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`headers()`');
CachedHeaders.set(prerenderStore, promise);
return promise;
}
function makeUntrackedHeaders(underlyingHeaders) {
const cachedHeaders = CachedHeaders.get(underlyingHeaders);
if (cachedHeaders) {
return cachedHeaders;
}
const promise = Promise.resolve(underlyingHeaders);
CachedHeaders.set(underlyingHeaders, promise);
return promise;
}
function makeUntrackedHeadersWithDevWarnings(underlyingHeaders, route, requestStore) {
if (requestStore.asyncApiPromises) {
const promise = requestStore.asyncApiPromises.headers;
return instrumentHeadersPromiseWithDevWarnings(promise, route);
}
const cachedHeaders = CachedHeaders.get(underlyingHeaders);
if (cachedHeaders) {
return cachedHeaders;
}
const promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingHeaders, requestStore, _stagedrendering.RenderStage.Runtime);
const proxiedPromise = instrumentHeadersPromiseWithDevWarnings(promise, route);
CachedHeaders.set(underlyingHeaders, proxiedPromise);
return proxiedPromise;
}
const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createHeadersAccessError);
function instrumentHeadersPromiseWithDevWarnings(promise, route) {
Object.defineProperties(promise, {
[Symbol.iterator]: replaceableWarningDescriptorForSymbolIterator(promise, route),
append: replaceableWarningDescriptor(promise, 'append', route),
delete: replaceableWarningDescriptor(promise, 'delete', route),
get: replaceableWarningDescriptor(promise, 'get', route),
has: replaceableWarningDescriptor(promise, 'has', route),
set: replaceableWarningDescriptor(promise, 'set', route),
getSetCookie: replaceableWarningDescriptor(promise, 'getSetCookie', route),
forEach: replaceableWarningDescriptor(promise, 'forEach', route),
keys: replaceableWarningDescriptor(promise, 'keys', route),
values: replaceableWarningDescriptor(promise, 'values', route),
entries: replaceableWarningDescriptor(promise, 'entries', route)
});
return promise;
}
function replaceableWarningDescriptor(target, prop, route) {
return {
enumerable: false,
get () {
warnForSyncAccess(route, `\`headers().${prop}\``);
return undefined;
},
set (value) {
Object.defineProperty(target, prop, {
value,
writable: true,
configurable: true
});
},
configurable: true
};
}
function replaceableWarningDescriptorForSymbolIterator(target, route) {
return {
enumerable: false,
get () {
warnForSyncAccess(route, '`...headers()` or similar iteration');
return undefined;
},
set (value) {
Object.defineProperty(target, Symbol.iterator, {
value,
writable: true,
enumerable: true,
configurable: true
});
},
configurable: true
};
}
function createHeadersAccessError(route, expression) {
const prefix = route ? `Route "${route}" ` : 'This route ';
return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`headers()\` returns a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
value: "E836",
enumerable: false,
configurable: true
});
}
//# sourceMappingURL=headers.js.map |