d147843c76
- Introduced blog routing using Next.js App Router - Implemented dynamic [slug] pages for blog posts - Added MDX-based content loading via lib/posts - Integrated shared TopBar layout with navigation - Established clear content, lib and component separation
220 lines
12 KiB
JavaScript
220 lines
12 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
Object.defineProperty(exports, "cookies", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return cookies;
|
|
}
|
|
});
|
|
const _requestcookies = require("../web/spec-extension/adapters/request-cookies");
|
|
const _cookies = require("../web/spec-extension/cookies");
|
|
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 cookies() {
|
|
const callingExpression = 'cookies';
|
|
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(// TODO(after): clarify that this only applies to pages?
|
|
`Route ${workStore.route} used \`cookies()\` inside \`after()\`. This is not supported. If you need this data inside an \`after()\` callback, use \`cookies()\` outside of the callback. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
|
|
value: "E843",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
if (workStore.forceStatic) {
|
|
// When using forceStatic we override all other logic and always just return an empty
|
|
// cookies object without tracking
|
|
const underlyingCookies = createEmptyCookies();
|
|
return makeUntrackedCookies(underlyingCookies);
|
|
}
|
|
if (workStore.dynamicShouldError) {
|
|
throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`cookies()\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
|
|
value: "E849",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
if (workUnitStore) {
|
|
switch(workUnitStore.type){
|
|
case 'cache':
|
|
const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`cookies()\` inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`cookies()\` 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: "E831",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Error.captureStackTrace(error, cookies);
|
|
workStore.invalidDynamicUsageError ??= error;
|
|
throw error;
|
|
case 'unstable-cache':
|
|
throw Object.defineProperty(new Error(`Route ${workStore.route} used \`cookies()\` 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 \`cookies()\` 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: "E846",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
case 'prerender':
|
|
return makeHangingCookies(workStore, workUnitStore);
|
|
case 'prerender-client':
|
|
const exportName = '`cookies`';
|
|
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: "E832",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
case 'prerender-ppr':
|
|
// We need track dynamic access here eagerly to keep continuity with
|
|
// how cookies has worked in PPR without cacheComponents.
|
|
return (0, _dynamicrendering.postponeWithTracking)(workStore.route, callingExpression, workUnitStore.dynamicTracking);
|
|
case 'prerender-legacy':
|
|
// We track dynamic access here so we don't need to wrap the cookies
|
|
// in individual property access tracking.
|
|
return (0, _dynamicrendering.throwToInterruptStaticGeneration)(callingExpression, workStore, workUnitStore);
|
|
case 'prerender-runtime':
|
|
return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, makeUntrackedCookies(workUnitStore.cookies));
|
|
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 makeUntrackedCookies(workUnitStore.cookies);
|
|
case 'request':
|
|
(0, _dynamicrendering.trackDynamicDataInDynamicRender)(workUnitStore);
|
|
let underlyingCookies;
|
|
if ((0, _requestcookies.areCookiesMutableInCurrentPhase)(workUnitStore)) {
|
|
// We can't conditionally return different types here based on the context.
|
|
// To avoid confusion, we always return the readonly type here.
|
|
underlyingCookies = workUnitStore.userspaceMutableCookies;
|
|
} else {
|
|
underlyingCookies = workUnitStore.cookies;
|
|
}
|
|
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 makeUntrackedCookiesWithDevWarnings(workUnitStore, underlyingCookies, workStore == null ? void 0 : workStore.route);
|
|
} else {
|
|
return makeUntrackedCookies(underlyingCookies);
|
|
}
|
|
default:
|
|
workUnitStore;
|
|
}
|
|
}
|
|
}
|
|
// If we end up here, there was no work store or work unit store present.
|
|
(0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
|
|
}
|
|
function createEmptyCookies() {
|
|
return _requestcookies.RequestCookiesAdapter.seal(new _cookies.RequestCookies(new Headers({})));
|
|
}
|
|
const CachedCookies = new WeakMap();
|
|
function makeHangingCookies(workStore, prerenderStore) {
|
|
const cachedPromise = CachedCookies.get(prerenderStore);
|
|
if (cachedPromise) {
|
|
return cachedPromise;
|
|
}
|
|
const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`cookies()`');
|
|
CachedCookies.set(prerenderStore, promise);
|
|
return promise;
|
|
}
|
|
function makeUntrackedCookies(underlyingCookies) {
|
|
const cachedCookies = CachedCookies.get(underlyingCookies);
|
|
if (cachedCookies) {
|
|
return cachedCookies;
|
|
}
|
|
const promise = Promise.resolve(underlyingCookies);
|
|
CachedCookies.set(underlyingCookies, promise);
|
|
return promise;
|
|
}
|
|
function makeUntrackedCookiesWithDevWarnings(requestStore, underlyingCookies, route) {
|
|
if (requestStore.asyncApiPromises) {
|
|
let promise;
|
|
if (underlyingCookies === requestStore.mutableCookies) {
|
|
promise = requestStore.asyncApiPromises.mutableCookies;
|
|
} else if (underlyingCookies === requestStore.cookies) {
|
|
promise = requestStore.asyncApiPromises.cookies;
|
|
} else {
|
|
throw Object.defineProperty(new _invarianterror.InvariantError('Received an underlying cookies object that does not match either `cookies` or `mutableCookies`'), "__NEXT_ERROR_CODE", {
|
|
value: "E890",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
return instrumentCookiesPromiseWithDevWarnings(promise, route);
|
|
}
|
|
const cachedCookies = CachedCookies.get(underlyingCookies);
|
|
if (cachedCookies) {
|
|
return cachedCookies;
|
|
}
|
|
const promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingCookies, requestStore, _stagedrendering.RenderStage.Runtime);
|
|
const proxiedPromise = instrumentCookiesPromiseWithDevWarnings(promise, route);
|
|
CachedCookies.set(underlyingCookies, proxiedPromise);
|
|
return proxiedPromise;
|
|
}
|
|
const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createCookiesAccessError);
|
|
function instrumentCookiesPromiseWithDevWarnings(promise, route) {
|
|
Object.defineProperties(promise, {
|
|
[Symbol.iterator]: replaceableWarningDescriptorForSymbolIterator(promise, route),
|
|
size: replaceableWarningDescriptor(promise, 'size', route),
|
|
get: replaceableWarningDescriptor(promise, 'get', route),
|
|
getAll: replaceableWarningDescriptor(promise, 'getAll', route),
|
|
has: replaceableWarningDescriptor(promise, 'has', route),
|
|
set: replaceableWarningDescriptor(promise, 'set', route),
|
|
delete: replaceableWarningDescriptor(promise, 'delete', route),
|
|
clear: replaceableWarningDescriptor(promise, 'clear', route),
|
|
toString: replaceableWarningDescriptor(promise, 'toString', route)
|
|
});
|
|
return promise;
|
|
}
|
|
function replaceableWarningDescriptor(target, prop, route) {
|
|
return {
|
|
enumerable: false,
|
|
get () {
|
|
warnForSyncAccess(route, `\`cookies().${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, '`...cookies()` or similar iteration');
|
|
return undefined;
|
|
},
|
|
set (value) {
|
|
Object.defineProperty(target, Symbol.iterator, {
|
|
value,
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
},
|
|
configurable: true
|
|
};
|
|
}
|
|
function createCookiesAccessError(route, expression) {
|
|
const prefix = route ? `Route "${route}" ` : 'This route ';
|
|
return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`cookies()\` 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: "E830",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
|
|
//# sourceMappingURL=cookies.js.map
|