Spaces:
Sleeping
Sleeping
| ; | |
| 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 |