Initial commit
This commit is contained in:
commit
78f8d225ee
21173 changed files with 2907774 additions and 0 deletions
520
node_modules/next/dist/server/request/search-params.js
generated
vendored
Normal file
520
node_modules/next/dist/server/request/search-params.js
generated
vendored
Normal file
|
|
@ -0,0 +1,520 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
createPrerenderSearchParamsForClientPage: null,
|
||||
createSearchParamsFromClient: null,
|
||||
createServerSearchParamsForMetadata: null,
|
||||
createServerSearchParamsForServerPage: null,
|
||||
makeErroringExoticSearchParamsForUseCache: 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;
|
||||
},
|
||||
makeErroringExoticSearchParamsForUseCache: function() {
|
||||
return makeErroringExoticSearchParamsForUseCache;
|
||||
}
|
||||
});
|
||||
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");
|
||||
const _scheduler = require("../../lib/scheduler");
|
||||
function createSearchParamsFromClient(underlyingSearchParams, workStore) {
|
||||
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
||||
if (workUnitStore) {
|
||||
switch(workUnitStore.type){
|
||||
case 'prerender':
|
||||
case 'prerender-ppr':
|
||||
case 'prerender-legacy':
|
||||
return createPrerenderSearchParams(workStore, workUnitStore);
|
||||
default:
|
||||
}
|
||||
}
|
||||
return createRenderSearchParams(underlyingSearchParams, workStore);
|
||||
}
|
||||
const createServerSearchParamsForMetadata = createServerSearchParamsForServerPage;
|
||||
function createServerSearchParamsForServerPage(underlyingSearchParams, workStore) {
|
||||
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
||||
if (workUnitStore) {
|
||||
switch(workUnitStore.type){
|
||||
case 'prerender':
|
||||
case 'prerender-ppr':
|
||||
case 'prerender-legacy':
|
||||
return createPrerenderSearchParams(workStore, workUnitStore);
|
||||
default:
|
||||
}
|
||||
}
|
||||
return createRenderSearchParams(underlyingSearchParams, workStore);
|
||||
}
|
||||
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 prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
|
||||
if (prerenderStore && prerenderStore.type === 'prerender') {
|
||||
// dynamicIO Prerender
|
||||
// We're prerendering in a mode that aborts (dynamicIO) and should stall
|
||||
// the promise to ensure the RSC side is considered dynamic
|
||||
return (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, '`searchParams`');
|
||||
}
|
||||
// We're prerendering in a mode that does not aborts. We resolve the promise without
|
||||
// any tracking because we're just transporting a value from server to client where the tracking
|
||||
// will be applied.
|
||||
return Promise.resolve({});
|
||||
}
|
||||
function createPrerenderSearchParams(workStore, prerenderStore) {
|
||||
if (workStore.forceStatic) {
|
||||
// When using forceStatic we override all other logic and always just return an empty
|
||||
// dictionary object.
|
||||
return Promise.resolve({});
|
||||
}
|
||||
if (prerenderStore.type === 'prerender') {
|
||||
// We are in a dynamicIO (PPR or otherwise) prerender
|
||||
return makeAbortingExoticSearchParams(workStore.route, prerenderStore);
|
||||
}
|
||||
// The remaining cases are prerender-ppr and prerender-legacy
|
||||
// We are in a legacy static generation and need to interrupt the prerender
|
||||
// when search params are accessed.
|
||||
return makeErroringExoticSearchParams(workStore, prerenderStore);
|
||||
}
|
||||
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' && !workStore.isPrefetchRequest) {
|
||||
return makeDynamicallyTrackedExoticSearchParamsWithDevWarnings(underlyingSearchParams, workStore);
|
||||
} else {
|
||||
return makeUntrackedExoticSearchParams(underlyingSearchParams, workStore);
|
||||
}
|
||||
}
|
||||
}
|
||||
const CachedSearchParams = new WeakMap();
|
||||
const CachedSearchParamsForUseCache = new WeakMap();
|
||||
function makeAbortingExoticSearchParams(route, prerenderStore) {
|
||||
const cachedSearchParams = CachedSearchParams.get(prerenderStore);
|
||||
if (cachedSearchParams) {
|
||||
return cachedSearchParams;
|
||||
}
|
||||
const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, '`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:
|
||||
{
|
||||
if (typeof prop === 'string' && !_reflectutils.wellKnownProperties.has(prop)) {
|
||||
const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', prop);
|
||||
const error = createSearchAccessError(route, expression);
|
||||
(0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, 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);
|
||||
const error = createSearchAccessError(route, expression);
|
||||
(0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
|
||||
}
|
||||
return _reflect.ReflectAdapter.has(target, prop);
|
||||
},
|
||||
ownKeys () {
|
||||
const expression = '`{...searchParams}`, `Object.keys(searchParams)`, or similar';
|
||||
const error = createSearchAccessError(route, expression);
|
||||
(0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
|
||||
}
|
||||
});
|
||||
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 dynamicIO)
|
||||
(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 dynamicIO)
|
||||
(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 dynamicIO)
|
||||
(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 dynamicIO)
|
||||
(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 dynamicIO)
|
||||
(0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
|
||||
} else {
|
||||
// Legacy Prerender
|
||||
(0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
|
||||
}
|
||||
}
|
||||
});
|
||||
CachedSearchParams.set(workStore, proxiedPromise);
|
||||
return proxiedPromise;
|
||||
}
|
||||
function makeErroringExoticSearchParamsForUseCache(workStore) {
|
||||
const cachedSearchParams = CachedSearchParamsForUseCache.get(workStore);
|
||||
if (cachedSearchParams) {
|
||||
return cachedSearchParams;
|
||||
}
|
||||
const promise = Promise.resolve({});
|
||||
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);
|
||||
}
|
||||
if (typeof prop === 'string' && (prop === 'then' || !_reflectutils.wellKnownProperties.has(prop))) {
|
||||
(0, _utils.throwForSearchParamsAccessInUseCache)(workStore);
|
||||
}
|
||||
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 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);
|
||||
}
|
||||
return _reflect.ReflectAdapter.has(target, prop);
|
||||
},
|
||||
ownKeys () {
|
||||
(0, _utils.throwForSearchParamsAccessInUseCache)(workStore);
|
||||
}
|
||||
});
|
||||
CachedSearchParamsForUseCache.set(workStore, proxiedPromise);
|
||||
return proxiedPromise;
|
||||
}
|
||||
function makeUntrackedExoticSearchParams(underlyingSearchParams, store) {
|
||||
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();
|
||||
(0, _dynamicrendering.trackDynamicDataInDynamicRender)(store, workUnitStore);
|
||||
return underlyingSearchParams[prop];
|
||||
},
|
||||
set (value) {
|
||||
Object.defineProperty(promise, prop, {
|
||||
value,
|
||||
writable: true,
|
||||
enumerable: true
|
||||
});
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
});
|
||||
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();
|
||||
(0, _dynamicrendering.trackDynamicDataInDynamicRender)(store, 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 = new Promise((resolve)=>(0, _scheduler.scheduleImmediate)(()=>resolve(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;
|
||||
}
|
||||
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 && workUnitStore.type === 'request' && 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
|
||||
const requestStore = workUnitStore;
|
||||
(0, _dynamicrendering.trackSynchronousRequestDataAccessInDev)(requestStore);
|
||||
}
|
||||
}
|
||||
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
|
||||
Loading…
Add table
Add a link
Reference in a new issue