653 lines
32 KiB
JavaScript
Executable File
653 lines
32 KiB
JavaScript
Executable File
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
0 && (module.exports = {
|
|
createPrerenderSearchParamsForClientPage: null,
|
|
createSearchParamsFromClient: null,
|
|
createServerSearchParamsForMetadata: null,
|
|
createServerSearchParamsForServerPage: null,
|
|
makeErroringSearchParamsForUseCache: null
|
|
});
|
|
function _export(target, all) {
|
|
for(var name in all)Object.defineProperty(target, name, {
|
|
enumerable: true,
|
|
get: all[name]
|
|
});
|
|
}
|
|
_export(exports, {
|
|
createPrerenderSearchParamsForClientPage: function() {
|
|
return createPrerenderSearchParamsForClientPage;
|
|
},
|
|
createSearchParamsFromClient: function() {
|
|
return createSearchParamsFromClient;
|
|
},
|
|
createServerSearchParamsForMetadata: function() {
|
|
return createServerSearchParamsForMetadata;
|
|
},
|
|
createServerSearchParamsForServerPage: function() {
|
|
return createServerSearchParamsForServerPage;
|
|
},
|
|
makeErroringSearchParamsForUseCache: function() {
|
|
return makeErroringSearchParamsForUseCache;
|
|
}
|
|
});
|
|
const _reflect = require("../web/spec-extension/adapters/reflect");
|
|
const _dynamicrendering = require("../app-render/dynamic-rendering");
|
|
const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
|
|
const _invarianterror = require("../../shared/lib/invariant-error");
|
|
const _dynamicrenderingutils = require("../dynamic-rendering-utils");
|
|
const _creatededupedbycallsiteservererrorlogger = require("../create-deduped-by-callsite-server-error-logger");
|
|
const _reflectutils = require("../../shared/lib/utils/reflect-utils");
|
|
const _utils = require("./utils");
|
|
function createSearchParamsFromClient(underlyingSearchParams, workStore) {
|
|
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
|
if (workUnitStore) {
|
|
switch(workUnitStore.type){
|
|
case 'prerender':
|
|
case 'prerender-client':
|
|
case 'prerender-ppr':
|
|
case 'prerender-legacy':
|
|
return createStaticPrerenderSearchParams(workStore, workUnitStore);
|
|
case 'prerender-runtime':
|
|
throw Object.defineProperty(new _invarianterror.InvariantError('createSearchParamsFromClient should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
|
|
value: "E769",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
case 'cache':
|
|
case 'private-cache':
|
|
case 'unstable-cache':
|
|
throw Object.defineProperty(new _invarianterror.InvariantError('createSearchParamsFromClient should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
|
|
value: "E739",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
case 'request':
|
|
return createRenderSearchParams(underlyingSearchParams, workStore);
|
|
default:
|
|
workUnitStore;
|
|
}
|
|
}
|
|
(0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
|
|
}
|
|
const createServerSearchParamsForMetadata = createServerSearchParamsForServerPage;
|
|
function createServerSearchParamsForServerPage(underlyingSearchParams, workStore) {
|
|
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
|
if (workUnitStore) {
|
|
switch(workUnitStore.type){
|
|
case 'prerender':
|
|
case 'prerender-client':
|
|
case 'prerender-ppr':
|
|
case 'prerender-legacy':
|
|
return createStaticPrerenderSearchParams(workStore, workUnitStore);
|
|
case 'cache':
|
|
case 'private-cache':
|
|
case 'unstable-cache':
|
|
throw Object.defineProperty(new _invarianterror.InvariantError('createServerSearchParamsForServerPage should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
|
|
value: "E747",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
case 'prerender-runtime':
|
|
return createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore);
|
|
case 'request':
|
|
return createRenderSearchParams(underlyingSearchParams, workStore);
|
|
default:
|
|
workUnitStore;
|
|
}
|
|
}
|
|
(0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
|
|
}
|
|
function createPrerenderSearchParamsForClientPage(workStore) {
|
|
if (workStore.forceStatic) {
|
|
// When using forceStatic we override all other logic and always just return an empty
|
|
// dictionary object.
|
|
return Promise.resolve({});
|
|
}
|
|
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
|
if (workUnitStore) {
|
|
switch(workUnitStore.type){
|
|
case 'prerender':
|
|
case 'prerender-client':
|
|
// We're prerendering in a mode that aborts (cacheComponents) and should stall
|
|
// the promise to ensure the RSC side is considered dynamic
|
|
return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`searchParams`');
|
|
case 'prerender-runtime':
|
|
throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
|
|
value: "E768",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
case 'cache':
|
|
case 'private-cache':
|
|
case 'unstable-cache':
|
|
throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
|
|
value: "E746",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
case 'prerender-ppr':
|
|
case 'prerender-legacy':
|
|
case 'request':
|
|
return Promise.resolve({});
|
|
default:
|
|
workUnitStore;
|
|
}
|
|
}
|
|
(0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
|
|
}
|
|
function createStaticPrerenderSearchParams(workStore, prerenderStore) {
|
|
if (workStore.forceStatic) {
|
|
// When using forceStatic we override all other logic and always just return an empty
|
|
// dictionary object.
|
|
return Promise.resolve({});
|
|
}
|
|
switch(prerenderStore.type){
|
|
case 'prerender':
|
|
case 'prerender-client':
|
|
// We are in a cacheComponents (PPR or otherwise) prerender
|
|
return makeHangingSearchParams(workStore, prerenderStore);
|
|
case 'prerender-ppr':
|
|
case 'prerender-legacy':
|
|
// We are in a legacy static generation and need to interrupt the
|
|
// prerender when search params are accessed.
|
|
return makeErroringExoticSearchParams(workStore, prerenderStore);
|
|
default:
|
|
return prerenderStore;
|
|
}
|
|
}
|
|
function createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore) {
|
|
return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, process.env.__NEXT_CACHE_COMPONENTS ? makeUntrackedSearchParams(underlyingSearchParams) : makeUntrackedExoticSearchParams(underlyingSearchParams));
|
|
}
|
|
function createRenderSearchParams(underlyingSearchParams, workStore) {
|
|
if (workStore.forceStatic) {
|
|
// When using forceStatic we override all other logic and always just return an empty
|
|
// dictionary object.
|
|
return Promise.resolve({});
|
|
} else {
|
|
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.
|
|
if (process.env.__NEXT_CACHE_COMPONENTS) {
|
|
return makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore);
|
|
}
|
|
return makeDynamicallyTrackedExoticSearchParamsWithDevWarnings(underlyingSearchParams, workStore);
|
|
} else {
|
|
if (process.env.__NEXT_CACHE_COMPONENTS) {
|
|
return makeUntrackedSearchParams(underlyingSearchParams);
|
|
}
|
|
return makeUntrackedExoticSearchParams(underlyingSearchParams);
|
|
}
|
|
}
|
|
}
|
|
const CachedSearchParams = new WeakMap();
|
|
const CachedSearchParamsForUseCache = new WeakMap();
|
|
function makeHangingSearchParams(workStore, prerenderStore) {
|
|
const cachedSearchParams = CachedSearchParams.get(prerenderStore);
|
|
if (cachedSearchParams) {
|
|
return cachedSearchParams;
|
|
}
|
|
const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`searchParams`');
|
|
const proxiedPromise = new Proxy(promise, {
|
|
get (target, prop, receiver) {
|
|
if (Object.hasOwn(promise, prop)) {
|
|
// The promise has this property directly. we must return it.
|
|
// We know it isn't a dynamic access because it can only be something
|
|
// that was previously written to the promise and thus not an underlying searchParam value
|
|
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
|
}
|
|
switch(prop){
|
|
case 'then':
|
|
{
|
|
const expression = '`await searchParams`, `searchParams.then`, or similar';
|
|
(0, _dynamicrendering.annotateDynamicAccess)(expression, prerenderStore);
|
|
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
|
}
|
|
case 'status':
|
|
{
|
|
const expression = '`use(searchParams)`, `searchParams.status`, or similar';
|
|
(0, _dynamicrendering.annotateDynamicAccess)(expression, prerenderStore);
|
|
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
|
}
|
|
default:
|
|
{
|
|
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
CachedSearchParams.set(prerenderStore, proxiedPromise);
|
|
return proxiedPromise;
|
|
}
|
|
function makeErroringExoticSearchParams(workStore, prerenderStore) {
|
|
const cachedSearchParams = CachedSearchParams.get(workStore);
|
|
if (cachedSearchParams) {
|
|
return cachedSearchParams;
|
|
}
|
|
const underlyingSearchParams = {};
|
|
// For search params we don't construct a ReactPromise because we want to interrupt
|
|
// rendering on any property access that was not set from outside and so we only want
|
|
// to have properties like value and status if React sets them.
|
|
const promise = Promise.resolve(underlyingSearchParams);
|
|
const proxiedPromise = new Proxy(promise, {
|
|
get (target, prop, receiver) {
|
|
if (Object.hasOwn(promise, prop)) {
|
|
// The promise has this property directly. we must return it.
|
|
// We know it isn't a dynamic access because it can only be something
|
|
// that was previously written to the promise and thus not an underlying searchParam value
|
|
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
|
}
|
|
switch(prop){
|
|
case 'then':
|
|
{
|
|
const expression = '`await searchParams`, `searchParams.then`, or similar';
|
|
if (workStore.dynamicShouldError) {
|
|
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
|
|
} else 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);
|
|
}
|
|
return;
|
|
}
|
|
case 'status':
|
|
{
|
|
const expression = '`use(searchParams)`, `searchParams.status`, or similar';
|
|
if (workStore.dynamicShouldError) {
|
|
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
|
|
} else 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);
|
|
}
|
|
return;
|
|
}
|
|
default:
|
|
{
|
|
if (typeof prop === 'string' && !_reflectutils.wellKnownProperties.has(prop)) {
|
|
const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', prop);
|
|
if (workStore.dynamicShouldError) {
|
|
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
|
|
} else 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);
|
|
}
|
|
}
|
|
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
|
}
|
|
}
|
|
},
|
|
has (target, prop) {
|
|
// We don't expect key checking to be used except for testing the existence of
|
|
// searchParams so we make all has tests trigger dynamic. this means that `promise.then`
|
|
// can resolve to the then function on the Promise prototype but 'then' in promise will assume
|
|
// you are testing whether the searchParams has a 'then' property.
|
|
if (typeof prop === 'string') {
|
|
const expression = (0, _reflectutils.describeHasCheckingStringProperty)('searchParams', prop);
|
|
if (workStore.dynamicShouldError) {
|
|
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
|
|
} else 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);
|
|
}
|
|
return false;
|
|
}
|
|
return _reflect.ReflectAdapter.has(target, prop);
|
|
},
|
|
ownKeys () {
|
|
const expression = '`{...searchParams}`, `Object.keys(searchParams)`, or similar';
|
|
if (workStore.dynamicShouldError) {
|
|
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
|
|
} else 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);
|
|
}
|
|
}
|
|
});
|
|
CachedSearchParams.set(workStore, proxiedPromise);
|
|
return proxiedPromise;
|
|
}
|
|
function makeErroringSearchParamsForUseCache(workStore) {
|
|
const cachedSearchParams = CachedSearchParamsForUseCache.get(workStore);
|
|
if (cachedSearchParams) {
|
|
return cachedSearchParams;
|
|
}
|
|
const promise = Promise.resolve({});
|
|
const proxiedPromise = new Proxy(promise, {
|
|
get: function get(target, prop, receiver) {
|
|
if (Object.hasOwn(promise, prop)) {
|
|
// The promise has this property directly. we must return it. We know it
|
|
// isn't a dynamic access because it can only be something that was
|
|
// previously written to the promise and thus not an underlying
|
|
// searchParam value
|
|
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
|
}
|
|
if (typeof prop === 'string' && (prop === 'then' || !_reflectutils.wellKnownProperties.has(prop))) {
|
|
(0, _utils.throwForSearchParamsAccessInUseCache)(workStore, get);
|
|
}
|
|
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
|
},
|
|
has: function has(target, prop) {
|
|
// We don't expect key checking to be used except for testing the existence of
|
|
// searchParams so we make all has tests throw an error. this means that `promise.then`
|
|
// can resolve to the then function on the Promise prototype but 'then' in promise will assume
|
|
// you are testing whether the searchParams has a 'then' property.
|
|
if (typeof prop === 'string' && (prop === 'then' || !_reflectutils.wellKnownProperties.has(prop))) {
|
|
(0, _utils.throwForSearchParamsAccessInUseCache)(workStore, has);
|
|
}
|
|
return _reflect.ReflectAdapter.has(target, prop);
|
|
},
|
|
ownKeys: function ownKeys() {
|
|
(0, _utils.throwForSearchParamsAccessInUseCache)(workStore, ownKeys);
|
|
}
|
|
});
|
|
CachedSearchParamsForUseCache.set(workStore, proxiedPromise);
|
|
return proxiedPromise;
|
|
}
|
|
function makeUntrackedExoticSearchParams(underlyingSearchParams) {
|
|
const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
|
|
if (cachedSearchParams) {
|
|
return cachedSearchParams;
|
|
}
|
|
// We don't use makeResolvedReactPromise here because searchParams
|
|
// supports copying with spread and we don't want to unnecessarily
|
|
// instrument the promise with spreadable properties of ReactPromise.
|
|
const promise = Promise.resolve(underlyingSearchParams);
|
|
CachedSearchParams.set(underlyingSearchParams, promise);
|
|
Object.keys(underlyingSearchParams).forEach((prop)=>{
|
|
if (!_reflectutils.wellKnownProperties.has(prop)) {
|
|
Object.defineProperty(promise, prop, {
|
|
get () {
|
|
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
|
if (workUnitStore) {
|
|
(0, _dynamicrendering.trackDynamicDataInDynamicRender)(workUnitStore);
|
|
}
|
|
return underlyingSearchParams[prop];
|
|
},
|
|
set (value) {
|
|
Object.defineProperty(promise, prop, {
|
|
value,
|
|
writable: true,
|
|
enumerable: true
|
|
});
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
});
|
|
return promise;
|
|
}
|
|
function makeUntrackedSearchParams(underlyingSearchParams) {
|
|
const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
|
|
if (cachedSearchParams) {
|
|
return cachedSearchParams;
|
|
}
|
|
const promise = Promise.resolve(underlyingSearchParams);
|
|
CachedSearchParams.set(underlyingSearchParams, promise);
|
|
return promise;
|
|
}
|
|
function makeDynamicallyTrackedExoticSearchParamsWithDevWarnings(underlyingSearchParams, store) {
|
|
const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
|
|
if (cachedSearchParams) {
|
|
return cachedSearchParams;
|
|
}
|
|
const proxiedProperties = new Set();
|
|
const unproxiedProperties = [];
|
|
// We have an unfortunate sequence of events that requires this initialization logic. We want to instrument the underlying
|
|
// searchParams object to detect if you are accessing values in dev. This is used for warnings and for things like the static prerender
|
|
// indicator. However when we pass this proxy to our Promise.resolve() below the VM checks if the resolved value is a promise by looking
|
|
// at the `.then` property. To our dynamic tracking logic this is indistinguishable from a `then` searchParam and so we would normally trigger
|
|
// dynamic tracking. However we know that this .then is not real dynamic access, it's just how thenables resolve in sequence. So we introduce
|
|
// this initialization concept so we omit the dynamic check until after we've constructed our resolved promise.
|
|
let promiseInitialized = false;
|
|
const proxiedUnderlying = new Proxy(underlyingSearchParams, {
|
|
get (target, prop, receiver) {
|
|
if (typeof prop === 'string' && promiseInitialized) {
|
|
if (store.dynamicShouldError) {
|
|
const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', prop);
|
|
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(store.route, expression);
|
|
}
|
|
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
|
if (workUnitStore) {
|
|
(0, _dynamicrendering.trackDynamicDataInDynamicRender)(workUnitStore);
|
|
}
|
|
}
|
|
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
|
},
|
|
has (target, prop) {
|
|
if (typeof prop === 'string') {
|
|
if (store.dynamicShouldError) {
|
|
const expression = (0, _reflectutils.describeHasCheckingStringProperty)('searchParams', prop);
|
|
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(store.route, expression);
|
|
}
|
|
}
|
|
return Reflect.has(target, prop);
|
|
},
|
|
ownKeys (target) {
|
|
if (store.dynamicShouldError) {
|
|
const expression = '`{...searchParams}`, `Object.keys(searchParams)`, or similar';
|
|
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(store.route, expression);
|
|
}
|
|
return Reflect.ownKeys(target);
|
|
}
|
|
});
|
|
// We don't use makeResolvedReactPromise here because searchParams
|
|
// supports copying with spread and we don't want to unnecessarily
|
|
// instrument the promise with spreadable properties of ReactPromise.
|
|
const promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingSearchParams);
|
|
promise.then(()=>{
|
|
promiseInitialized = true;
|
|
});
|
|
Object.keys(underlyingSearchParams).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
|
|
unproxiedProperties.push(prop);
|
|
} else {
|
|
proxiedProperties.add(prop);
|
|
Object.defineProperty(promise, prop, {
|
|
get () {
|
|
return proxiedUnderlying[prop];
|
|
},
|
|
set (newValue) {
|
|
Object.defineProperty(promise, prop, {
|
|
value: newValue,
|
|
writable: true,
|
|
enumerable: true
|
|
});
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
});
|
|
const proxiedPromise = new Proxy(promise, {
|
|
get (target, prop, receiver) {
|
|
if (prop === 'then' && store.dynamicShouldError) {
|
|
const expression = '`searchParams.then`';
|
|
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(store.route, expression);
|
|
}
|
|
if (typeof prop === 'string') {
|
|
if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
|
|
// the underlying searchParams.
|
|
Reflect.has(target, prop) === false)) {
|
|
const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', prop);
|
|
syncIODev(store.route, expression);
|
|
}
|
|
}
|
|
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
|
},
|
|
set (target, prop, value, receiver) {
|
|
if (typeof prop === 'string') {
|
|
proxiedProperties.delete(prop);
|
|
}
|
|
return Reflect.set(target, prop, value, receiver);
|
|
},
|
|
has (target, prop) {
|
|
if (typeof prop === 'string') {
|
|
if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
|
|
// the underlying searchParams.
|
|
Reflect.has(target, prop) === false)) {
|
|
const expression = (0, _reflectutils.describeHasCheckingStringProperty)('searchParams', prop);
|
|
syncIODev(store.route, expression);
|
|
}
|
|
}
|
|
return Reflect.has(target, prop);
|
|
},
|
|
ownKeys (target) {
|
|
const expression = '`Object.keys(searchParams)` or similar';
|
|
syncIODev(store.route, expression, unproxiedProperties);
|
|
return Reflect.ownKeys(target);
|
|
}
|
|
});
|
|
CachedSearchParams.set(underlyingSearchParams, proxiedPromise);
|
|
return proxiedPromise;
|
|
}
|
|
// Similar to `makeDynamicallyTrackedExoticSearchParamsWithDevWarnings`, but
|
|
// just logging the sync access without actually defining the search params on
|
|
// the promise.
|
|
function makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, store) {
|
|
const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
|
|
if (cachedSearchParams) {
|
|
return cachedSearchParams;
|
|
}
|
|
const proxiedProperties = new Set();
|
|
const unproxiedProperties = [];
|
|
const promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingSearchParams);
|
|
Object.keys(underlyingSearchParams).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
|
|
unproxiedProperties.push(prop);
|
|
} else {
|
|
proxiedProperties.add(prop);
|
|
}
|
|
});
|
|
const proxiedPromise = new Proxy(promise, {
|
|
get (target, prop, receiver) {
|
|
if (typeof prop === 'string') {
|
|
if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
|
|
// the underlying searchParams.
|
|
Reflect.has(target, prop) === false)) {
|
|
const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', prop);
|
|
warnForSyncAccess(store.route, expression);
|
|
}
|
|
}
|
|
return _reflect.ReflectAdapter.get(target, prop, receiver);
|
|
},
|
|
set (target, prop, value, receiver) {
|
|
if (typeof prop === 'string') {
|
|
proxiedProperties.delete(prop);
|
|
}
|
|
return Reflect.set(target, prop, value, receiver);
|
|
},
|
|
has (target, prop) {
|
|
if (typeof prop === 'string') {
|
|
if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
|
|
// the underlying searchParams.
|
|
Reflect.has(target, prop) === false)) {
|
|
const expression = (0, _reflectutils.describeHasCheckingStringProperty)('searchParams', prop);
|
|
warnForSyncAccess(store.route, expression);
|
|
}
|
|
}
|
|
return Reflect.has(target, prop);
|
|
},
|
|
ownKeys (target) {
|
|
const expression = '`Object.keys(searchParams)` or similar';
|
|
warnForIncompleteEnumeration(store.route, expression, unproxiedProperties);
|
|
return Reflect.ownKeys(target);
|
|
}
|
|
});
|
|
CachedSearchParams.set(underlyingSearchParams, proxiedPromise);
|
|
return proxiedPromise;
|
|
}
|
|
function syncIODev(route, expression, missingProperties) {
|
|
// In all cases we warn normally
|
|
if (missingProperties && missingProperties.length > 0) {
|
|
warnForIncompleteEnumeration(route, expression, missingProperties);
|
|
} else {
|
|
warnForSyncAccess(route, expression);
|
|
}
|
|
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
|
if (workUnitStore) {
|
|
switch(workUnitStore.type){
|
|
case 'request':
|
|
if (workUnitStore.prerenderPhase === true) {
|
|
// When we're rendering dynamically in dev, we need to advance out of
|
|
// the Prerender environment when we read Request data synchronously.
|
|
(0, _dynamicrendering.trackSynchronousRequestDataAccessInDev)(workUnitStore);
|
|
}
|
|
break;
|
|
case 'prerender':
|
|
case 'prerender-client':
|
|
case 'prerender-runtime':
|
|
case 'prerender-ppr':
|
|
case 'prerender-legacy':
|
|
case 'cache':
|
|
case 'private-cache':
|
|
case 'unstable-cache':
|
|
break;
|
|
default:
|
|
workUnitStore;
|
|
}
|
|
}
|
|
}
|
|
const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createSearchAccessError);
|
|
const warnForIncompleteEnumeration = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createIncompleteEnumerationError);
|
|
function createSearchAccessError(route, expression) {
|
|
const prefix = route ? `Route "${route}" ` : 'This route ';
|
|
return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`searchParams\` should be awaited before using its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
|
|
value: "E249",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
function createIncompleteEnumerationError(route, expression, missingProperties) {
|
|
const prefix = route ? `Route "${route}" ` : 'This route ';
|
|
return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`searchParams\` should be awaited before using its properties. ` + `The following properties were not available through enumeration ` + `because they conflict with builtin or well-known property names: ` + `${describeListOfPropertyNames(missingProperties)}. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
|
|
value: "E2",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
function describeListOfPropertyNames(properties) {
|
|
switch(properties.length){
|
|
case 0:
|
|
throw Object.defineProperty(new _invarianterror.InvariantError('Expected describeListOfPropertyNames to be called with a non-empty list of strings.'), "__NEXT_ERROR_CODE", {
|
|
value: "E531",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
case 1:
|
|
return `\`${properties[0]}\``;
|
|
case 2:
|
|
return `\`${properties[0]}\` and \`${properties[1]}\``;
|
|
default:
|
|
{
|
|
let description = '';
|
|
for(let i = 0; i < properties.length - 1; i++){
|
|
description += `\`${properties[i]}\`, `;
|
|
}
|
|
description += `, and \`${properties[properties.length - 1]}\``;
|
|
return description;
|
|
}
|
|
}
|
|
}
|
|
|
|
//# sourceMappingURL=search-params.js.map
|