309 lines
14 KiB
JavaScript
Executable File
309 lines
14 KiB
JavaScript
Executable File
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
0 && (module.exports = {
|
|
getRootParam: null,
|
|
unstable_rootParams: null
|
|
});
|
|
function _export(target, all) {
|
|
for(var name in all)Object.defineProperty(target, name, {
|
|
enumerable: true,
|
|
get: all[name]
|
|
});
|
|
}
|
|
_export(exports, {
|
|
getRootParam: function() {
|
|
return getRootParam;
|
|
},
|
|
unstable_rootParams: function() {
|
|
return unstable_rootParams;
|
|
}
|
|
});
|
|
const _invarianterror = require("../../shared/lib/invariant-error");
|
|
const _dynamicrendering = require("../app-render/dynamic-rendering");
|
|
const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
|
|
const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
|
|
const _dynamicrenderingutils = require("../dynamic-rendering-utils");
|
|
const _reflectutils = require("../../shared/lib/utils/reflect-utils");
|
|
const _actionasyncstorageexternal = require("../app-render/action-async-storage.external");
|
|
const _log = require("../../build/output/log");
|
|
const CachedParams = new WeakMap();
|
|
async function unstable_rootParams() {
|
|
(0, _log.warnOnce)('`unstable_rootParams()` is deprecated and will be removed in an upcoming major release. Import specific root params from `next/root-params` instead.');
|
|
const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
|
|
if (!workStore) {
|
|
throw Object.defineProperty(new _invarianterror.InvariantError('Missing workStore in unstable_rootParams'), "__NEXT_ERROR_CODE", {
|
|
value: "E615",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
|
if (!workUnitStore) {
|
|
throw Object.defineProperty(new Error(`Route ${workStore.route} used \`unstable_rootParams()\` in Pages Router. This API is only available within App Router.`), "__NEXT_ERROR_CODE", {
|
|
value: "E641",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
switch(workUnitStore.type){
|
|
case 'cache':
|
|
case 'unstable-cache':
|
|
{
|
|
throw Object.defineProperty(new Error(`Route ${workStore.route} used \`unstable_rootParams()\` inside \`"use cache"\` or \`unstable_cache\`. Support for this API inside cache scopes is planned for a future version of Next.js.`), "__NEXT_ERROR_CODE", {
|
|
value: "E642",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
case 'prerender':
|
|
case 'prerender-client':
|
|
case 'prerender-ppr':
|
|
case 'prerender-legacy':
|
|
return createPrerenderRootParams(workUnitStore.rootParams, workStore, workUnitStore);
|
|
case 'private-cache':
|
|
case 'prerender-runtime':
|
|
case 'request':
|
|
return Promise.resolve(workUnitStore.rootParams);
|
|
default:
|
|
return workUnitStore;
|
|
}
|
|
}
|
|
function createPrerenderRootParams(underlyingParams, workStore, prerenderStore) {
|
|
switch(prerenderStore.type){
|
|
case 'prerender-client':
|
|
{
|
|
const exportName = '`unstable_rootParams`';
|
|
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':
|
|
{
|
|
const fallbackParams = prerenderStore.fallbackRouteParams;
|
|
if (fallbackParams) {
|
|
for(const key in underlyingParams){
|
|
if (fallbackParams.has(key)) {
|
|
const cachedParams = CachedParams.get(underlyingParams);
|
|
if (cachedParams) {
|
|
return cachedParams;
|
|
}
|
|
const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`unstable_rootParams`');
|
|
CachedParams.set(underlyingParams, promise);
|
|
return promise;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 'prerender-ppr':
|
|
{
|
|
const fallbackParams = prerenderStore.fallbackRouteParams;
|
|
if (fallbackParams) {
|
|
for(const key in underlyingParams){
|
|
if (fallbackParams.has(key)) {
|
|
// We have fallback params at this level so we need to make an erroring
|
|
// params object which will postpone if you access the fallback params
|
|
return makeErroringRootParams(underlyingParams, fallbackParams, workStore, prerenderStore);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 'prerender-legacy':
|
|
break;
|
|
default:
|
|
prerenderStore;
|
|
}
|
|
// We don't have any fallback params so we have an entirely static safe params object
|
|
return Promise.resolve(underlyingParams);
|
|
}
|
|
function makeErroringRootParams(underlyingParams, fallbackParams, workStore, prerenderStore) {
|
|
const cachedParams = CachedParams.get(underlyingParams);
|
|
if (cachedParams) {
|
|
return cachedParams;
|
|
}
|
|
const augmentedUnderlying = {
|
|
...underlyingParams
|
|
};
|
|
// We don't use makeResolvedReactPromise here because params
|
|
// supports copying with spread and we don't want to unnecessarily
|
|
// instrument the promise with spreadable properties of ReactPromise.
|
|
const promise = Promise.resolve(augmentedUnderlying);
|
|
CachedParams.set(underlyingParams, promise);
|
|
Object.keys(underlyingParams).forEach((prop)=>{
|
|
if (_reflectutils.wellKnownProperties.has(prop)) {
|
|
// These properties cannot be shadowed because they need to be the
|
|
// true underlying value for Promises to work correctly at runtime
|
|
} else {
|
|
if (fallbackParams.has(prop)) {
|
|
Object.defineProperty(augmentedUnderlying, prop, {
|
|
get () {
|
|
const expression = (0, _reflectutils.describeStringPropertyAccess)('unstable_rootParams', prop);
|
|
// In most dynamic APIs we also throw if `dynamic = "error"` however
|
|
// for params is only dynamic when we're generating a fallback shell
|
|
// and even when `dynamic = "error"` we still support generating dynamic
|
|
// fallback shells
|
|
// TODO remove this comment when cacheComponents is the default since there
|
|
// will be no `dynamic = "error"`
|
|
if (prerenderStore.type === 'prerender-ppr') {
|
|
// PPR Prerender (no cacheComponents)
|
|
(0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
|
|
} else {
|
|
// Legacy Prerender
|
|
(0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
|
|
}
|
|
},
|
|
enumerable: true
|
|
});
|
|
} else {
|
|
;
|
|
promise[prop] = underlyingParams[prop];
|
|
}
|
|
}
|
|
});
|
|
return promise;
|
|
}
|
|
function getRootParam(paramName) {
|
|
const apiName = `\`import('next/root-params').${paramName}()\``;
|
|
const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
|
|
if (!workStore) {
|
|
throw Object.defineProperty(new _invarianterror.InvariantError(`Missing workStore in ${apiName}`), "__NEXT_ERROR_CODE", {
|
|
value: "E764",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
|
if (!workUnitStore) {
|
|
throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} outside of a Server Component. This is not allowed.`), "__NEXT_ERROR_CODE", {
|
|
value: "E774",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
const actionStore = _actionasyncstorageexternal.actionAsyncStorage.getStore();
|
|
if (actionStore) {
|
|
if (actionStore.isAppRoute) {
|
|
// TODO(root-params): add support for route handlers
|
|
throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} inside a Route Handler. Support for this API in Route Handlers is planned for a future version of Next.js.`), "__NEXT_ERROR_CODE", {
|
|
value: "E765",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
if (actionStore.isAction && workUnitStore.phase === 'action') {
|
|
// Actions are not fundamentally tied to a route (even if they're always submitted from some page),
|
|
// so root params would be inconsistent if an action is called from multiple roots.
|
|
// Make sure we check if the phase is "action" - we should not error in the rerender
|
|
// after an action revalidates or updates cookies (which will still have `actionStore.isAction === true`)
|
|
throw Object.defineProperty(new Error(`${apiName} was used inside a Server Action. This is not supported. Functions from 'next/root-params' can only be called in the context of a route.`), "__NEXT_ERROR_CODE", {
|
|
value: "E766",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
}
|
|
switch(workUnitStore.type){
|
|
case 'unstable-cache':
|
|
case 'cache':
|
|
{
|
|
throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} inside \`"use cache"\` or \`unstable_cache\`. Support for this API inside cache scopes is planned for a future version of Next.js.`), "__NEXT_ERROR_CODE", {
|
|
value: "E760",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
case 'prerender':
|
|
case 'prerender-client':
|
|
case 'prerender-ppr':
|
|
case 'prerender-legacy':
|
|
{
|
|
return createPrerenderRootParamPromise(paramName, workStore, workUnitStore, apiName);
|
|
}
|
|
case 'private-cache':
|
|
case 'prerender-runtime':
|
|
case 'request':
|
|
{
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
workUnitStore;
|
|
}
|
|
}
|
|
return Promise.resolve(workUnitStore.rootParams[paramName]);
|
|
}
|
|
function createPrerenderRootParamPromise(paramName, workStore, prerenderStore, apiName) {
|
|
switch(prerenderStore.type){
|
|
case 'prerender-client':
|
|
{
|
|
throw Object.defineProperty(new _invarianterror.InvariantError(`${apiName} must not be used within a client component. Next.js should be preventing ${apiName} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
|
|
value: "E693",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
case 'prerender':
|
|
case 'prerender-legacy':
|
|
case 'prerender-ppr':
|
|
default:
|
|
}
|
|
const underlyingParams = prerenderStore.rootParams;
|
|
switch(prerenderStore.type){
|
|
case 'prerender':
|
|
{
|
|
// We are in a dynamicIO prerender.
|
|
// The param is a fallback, so it should be treated as dynamic.
|
|
if (prerenderStore.fallbackRouteParams && prerenderStore.fallbackRouteParams.has(paramName)) {
|
|
return (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, apiName);
|
|
}
|
|
break;
|
|
}
|
|
case 'prerender-ppr':
|
|
{
|
|
// We aren't in a dynamicIO prerender, but the param is a fallback,
|
|
// so we need to make an erroring params object which will postpone/error if you access it
|
|
if (prerenderStore.fallbackRouteParams && prerenderStore.fallbackRouteParams.has(paramName)) {
|
|
return makeErroringRootParamPromise(paramName, workStore, prerenderStore, apiName);
|
|
}
|
|
break;
|
|
}
|
|
case 'prerender-legacy':
|
|
{
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
prerenderStore;
|
|
}
|
|
}
|
|
// If the param is not a fallback param, we just return the statically available value.
|
|
return Promise.resolve(underlyingParams[paramName]);
|
|
}
|
|
/** Deliberately async -- we want to create a rejected promise, not error synchronously. */ async function makeErroringRootParamPromise(paramName, workStore, prerenderStore, apiName) {
|
|
const expression = (0, _reflectutils.describeStringPropertyAccess)(apiName, paramName);
|
|
// In most dynamic APIs, we also throw if `dynamic = "error"`.
|
|
// However, root params are only dynamic when we're generating a fallback shell,
|
|
// and even with `dynamic = "error"` we still support generating dynamic fallback shells.
|
|
// TODO: remove this comment when dynamicIO is the default since there will be no `dynamic = "error"`
|
|
switch(prerenderStore.type){
|
|
case 'prerender-ppr':
|
|
{
|
|
return (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
|
|
}
|
|
case 'prerender-legacy':
|
|
{
|
|
return (0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
|
|
}
|
|
default:
|
|
{
|
|
prerenderStore;
|
|
}
|
|
}
|
|
}
|
|
|
|
//# sourceMappingURL=root-params.js.map
|