(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push([typeof document === "object" ? document.currentScript : undefined,
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/router/utils/disable-smooth-scroll.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$00__$2d$__projet$2f$plumeia$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "disableSmoothScrollDuringRouteTransition", {
enumerable: true,
get: function() {
return disableSmoothScrollDuringRouteTransition;
}
});
const _warnonce = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/utils/warn-once.js [app-client] (ecmascript)");
function disableSmoothScrollDuringRouteTransition(fn, options = {}) {
// if only the hash is changed, we don't need to disable smooth scrolling
// we only care to prevent smooth scrolling when navigating to a new page to avoid jarring UX
if (options.onlyHashChange) {
fn();
return;
}
const htmlElement = document.documentElement;
const hasDataAttribute = htmlElement.dataset.scrollBehavior === 'smooth';
if (!hasDataAttribute) {
// Warn if smooth scrolling is detected but no data attribute is present
if (("TURBOPACK compile-time value", "development") === 'development' && getComputedStyle(htmlElement).scrollBehavior === 'smooth') {
(0, _warnonce.warnOnce)('Detected `scroll-behavior: smooth` on the `` element. To disable smooth scrolling during route transitions, ' + 'add `data-scroll-behavior="smooth"` to your element. ' + 'Learn more: https://nextjs.org/docs/messages/missing-data-scroll-behavior');
}
// No smooth scrolling configured, run directly without style manipulation
fn();
return;
}
// Proceed with temporarily disabling smooth scrolling
const existing = htmlElement.style.scrollBehavior;
htmlElement.style.scrollBehavior = 'auto';
if (!options.dontForceLayout) {
// In Chrome-based browsers we need to force reflow before calling `scrollTo`.
// Otherwise it will not pickup the change in scrollBehavior
// More info here: https://github.com/vercel/next.js/issues/40719#issuecomment-1336248042
htmlElement.getClientRects();
}
fn();
htmlElement.style.scrollBehavior = existing;
} //# sourceMappingURL=disable-smooth-scroll.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/bfcache.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$00__$2d$__projet$2f$plumeia$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "useRouterBFCache", {
enumerable: true,
get: function() {
return useRouterBFCache;
}
});
const _react = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)");
// When the flag is disabled, only track the currently active tree
const MAX_BF_CACHE_ENTRIES = ("TURBOPACK compile-time falsy", 0) ? "TURBOPACK unreachable" : 1;
function useRouterBFCache(activeTree, activeStateKey) {
// The currently active entry. The entries form a linked list, sorted in
// order of most recently active. This allows us to reuse parts of the list
// without cloning, unless there's a reordering or removal.
// TODO: Once we start tracking back/forward history at each route level,
// we should use the history order instead. In other words, when traversing
// to an existing entry as a result of a popstate event, we should maintain
// the existing order instead of moving it to the front of the list. I think
// an initial implementation of this could be to pass an incrementing id
// to history.pushState/replaceState, then use that here for ordering.
const [prevActiveEntry, setPrevActiveEntry] = (0, _react.useState)(()=>{
const initialEntry = {
tree: activeTree,
stateKey: activeStateKey,
next: null
};
return initialEntry;
});
if (prevActiveEntry.tree === activeTree) {
// Fast path. The active tree hasn't changed, so we can reuse the
// existing state.
return prevActiveEntry;
}
// The route tree changed. Note that this doesn't mean that the tree changed
// *at this level* — the change may be due to a child route. Either way, we
// need to either add or update the router tree in the bfcache.
//
// The rest of the code looks more complicated than it actually is because we
// can't mutate the state in place; we have to copy-on-write.
// Create a new entry for the active cache key. This is the head of the new
// linked list.
const newActiveEntry = {
tree: activeTree,
stateKey: activeStateKey,
next: null
};
// We need to append the old list onto the new list. If the head of the new
// list was already present in the cache, then we'll need to clone everything
// that came before it. Then we can reuse the rest.
let n = 1;
let oldEntry = prevActiveEntry;
let clonedEntry = newActiveEntry;
while(oldEntry !== null && n < MAX_BF_CACHE_ENTRIES){
if (oldEntry.stateKey === activeStateKey) {
// Fast path. This entry in the old list that corresponds to the key that
// is now active. We've already placed a clone of this entry at the front
// of the new list. We can reuse the rest of the old list without cloning.
// NOTE: We don't need to worry about eviction in this case because we
// haven't increased the size of the cache, and we assume the max size
// is constant across renders. If we were to change it to a dynamic limit,
// then the implementation would need to account for that.
clonedEntry.next = oldEntry.next;
break;
} else {
// Clone the entry and append it to the list.
n++;
const entry = {
tree: oldEntry.tree,
stateKey: oldEntry.stateKey,
next: null
};
clonedEntry.next = entry;
clonedEntry = entry;
}
oldEntry = oldEntry.next;
}
setPrevActiveEntry(newActiveEntry);
return newActiveEntry;
}
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
Object.defineProperty(exports.default, '__esModule', {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=bfcache.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/layout-router.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$00__$2d$__projet$2f$plumeia$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
'use client';
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, /**
* OuterLayoutRouter handles the current segment as well as rendering of other segments.
* It can be rendered next to each other with a different `parallelRouterKey`, allowing for Parallel routes.
*/ "default", {
enumerable: true,
get: function() {
return OuterLayoutRouter;
}
});
const _interop_require_default = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/@swc/helpers/cjs/_interop_require_default.cjs [app-client] (ecmascript)");
const _interop_require_wildcard = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs [app-client] (ecmascript)");
const _jsxruntime = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)"));
const _reactdom = /*#__PURE__*/ _interop_require_default._(__turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/compiled/react-dom/index.js [app-client] (ecmascript)"));
const _approutercontextsharedruntime = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js [app-client] (ecmascript)");
const _unresolvedthenable = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/unresolved-thenable.js [app-client] (ecmascript)");
const _errorboundary = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/error-boundary.js [app-client] (ecmascript)");
const _matchsegments = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/match-segments.js [app-client] (ecmascript)");
const _disablesmoothscroll = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/router/utils/disable-smooth-scroll.js [app-client] (ecmascript)");
const _redirectboundary = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/redirect-boundary.js [app-client] (ecmascript)");
const _errorboundary1 = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/http-access-fallback/error-boundary.js [app-client] (ecmascript)");
const _createroutercachekey = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/router-reducer/create-router-cache-key.js [app-client] (ecmascript)");
const _bfcache = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/bfcache.js [app-client] (ecmascript)");
const _apppaths = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/router/utils/app-paths.js [app-client] (ecmascript)");
const _hooksclientcontextsharedruntime = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.js [app-client] (ecmascript)");
const _routeparams = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/route-params.js [app-client] (ecmascript)");
const _pprnavigations = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/router-reducer/ppr-navigations.js [app-client] (ecmascript)");
const __DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = _reactdom.default.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
// TODO-APP: Replace with new React API for finding dom nodes without a `ref` when available
/**
* Wraps ReactDOM.findDOMNode with additional logic to hide React Strict Mode warning
*/ function findDOMNode(instance) {
// Tree-shake for server bundle
if (typeof window === 'undefined') return null;
// __DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE.findDOMNode is null during module init.
// We need to lazily reference it.
const internal_reactDOMfindDOMNode = __DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE.findDOMNode;
return internal_reactDOMfindDOMNode(instance);
}
const rectProperties = [
'bottom',
'height',
'left',
'right',
'top',
'width',
'x',
'y'
];
/**
* Check if a HTMLElement is hidden or fixed/sticky position
*/ function shouldSkipElement(element) {
// we ignore fixed or sticky positioned elements since they'll likely pass the "in-viewport" check
// and will result in a situation we bail on scroll because of something like a fixed nav,
// even though the actual page content is offscreen
if ([
'sticky',
'fixed'
].includes(getComputedStyle(element).position)) {
return true;
}
// Uses `getBoundingClientRect` to check if the element is hidden instead of `offsetParent`
// because `offsetParent` doesn't consider document/body
const rect = element.getBoundingClientRect();
return rectProperties.every((item)=>rect[item] === 0);
}
/**
* Check if the top corner of the HTMLElement is in the viewport.
*/ function topOfElementInViewport(element, viewportHeight) {
const rect = element.getBoundingClientRect();
return rect.top >= 0 && rect.top <= viewportHeight;
}
/**
* Find the DOM node for a hash fragment.
* If `top` the page has to scroll to the top of the page. This mirrors the browser's behavior.
* If the hash fragment is an id, the page has to scroll to the element with that id.
* If the hash fragment is a name, the page has to scroll to the first element with that name.
*/ function getHashFragmentDomNode(hashFragment) {
// If the hash fragment is `top` the page has to scroll to the top of the page.
if (hashFragment === 'top') {
return document.body;
}
// If the hash fragment is an id, the page has to scroll to the element with that id.
return document.getElementById(hashFragment) ?? // If the hash fragment is a name, the page has to scroll to the first element with that name.
document.getElementsByName(hashFragment)[0];
}
class InnerScrollAndFocusHandler extends _react.default.Component {
componentDidMount() {
this.handlePotentialScroll();
}
componentDidUpdate() {
// Because this property is overwritten in handlePotentialScroll it's fine to always run it when true as it'll be set to false for subsequent renders.
if (this.props.focusAndScrollRef.apply) {
this.handlePotentialScroll();
}
}
render() {
return this.props.children;
}
constructor(...args){
super(...args), this.handlePotentialScroll = ()=>{
// Handle scroll and focus, it's only applied once in the first useEffect that triggers that changed.
const { focusAndScrollRef, segmentPath } = this.props;
if (focusAndScrollRef.apply) {
// segmentPaths is an array of segment paths that should be scrolled to
// if the current segment path is not in the array, the scroll is not applied
// unless the array is empty, in which case the scroll is always applied
if (focusAndScrollRef.segmentPaths.length !== 0 && !focusAndScrollRef.segmentPaths.some((scrollRefSegmentPath)=>segmentPath.every((segment, index)=>(0, _matchsegments.matchSegment)(segment, scrollRefSegmentPath[index])))) {
return;
}
let domNode = null;
const hashFragment = focusAndScrollRef.hashFragment;
if (hashFragment) {
domNode = getHashFragmentDomNode(hashFragment);
}
// `findDOMNode` is tricky because it returns just the first child if the component is a fragment.
// This already caused a bug where the first child was a in head.
if (!domNode) {
domNode = findDOMNode(this);
}
// If there is no DOM node this layout-router level is skipped. It'll be handled higher-up in the tree.
if (!(domNode instanceof Element)) {
return;
}
// Verify if the element is a HTMLElement and if we want to consider it for scroll behavior.
// If the element is skipped, try to select the next sibling and try again.
while(!(domNode instanceof HTMLElement) || shouldSkipElement(domNode)){
if ("TURBOPACK compile-time truthy", 1) {
if (domNode.parentElement?.localName === 'head') {
// TODO: We enter this state when metadata was rendered as part of the page or via Next.js.
// This is always a bug in Next.js and caused by React hoisting metadata.
// We need to replace `findDOMNode` in favor of Fragment Refs (when available) so that we can skip over metadata.
}
}
// No siblings found that match the criteria are found, so handle scroll higher up in the tree instead.
if (domNode.nextElementSibling === null) {
return;
}
domNode = domNode.nextElementSibling;
}
// State is mutated to ensure that the focus and scroll is applied only once.
focusAndScrollRef.apply = false;
focusAndScrollRef.hashFragment = null;
focusAndScrollRef.segmentPaths = [];
(0, _disablesmoothscroll.disableSmoothScrollDuringRouteTransition)(()=>{
// In case of hash scroll, we only need to scroll the element into view
if (hashFragment) {
;
domNode.scrollIntoView();
return;
}
// Store the current viewport height because reading `clientHeight` causes a reflow,
// and it won't change during this function.
const htmlElement = document.documentElement;
const viewportHeight = htmlElement.clientHeight;
// If the element's top edge is already in the viewport, exit early.
if (topOfElementInViewport(domNode, viewportHeight)) {
return;
}
// Otherwise, try scrolling go the top of the document to be backward compatible with pages
// scrollIntoView() called on `` element scrolls horizontally on chrome and firefox (that shouldn't happen)
// We could use it to scroll horizontally following RTL but that also seems to be broken - it will always scroll left
// scrollLeft = 0 also seems to ignore RTL and manually checking for RTL is too much hassle so we will scroll just vertically
htmlElement.scrollTop = 0;
// Scroll to domNode if domNode is not in viewport when scrolled to top of document
if (!topOfElementInViewport(domNode, viewportHeight)) {
// Scroll into view doesn't scroll horizontally by default when not needed
;
domNode.scrollIntoView();
}
}, {
// We will force layout by querying domNode position
dontForceLayout: true,
onlyHashChange: focusAndScrollRef.onlyHashChange
});
// Mutate after scrolling so that it can be read by `disableSmoothScrollDuringRouteTransition`
focusAndScrollRef.onlyHashChange = false;
// Set focus on the element
domNode.focus();
}
};
}
}
function ScrollAndFocusHandler({ segmentPath, children }) {
const context = (0, _react.useContext)(_approutercontextsharedruntime.GlobalLayoutRouterContext);
if (!context) {
throw Object.defineProperty(new Error('invariant global layout router not mounted'), "__NEXT_ERROR_CODE", {
value: "E473",
enumerable: false,
configurable: true
});
}
return /*#__PURE__*/ (0, _jsxruntime.jsx)(InnerScrollAndFocusHandler, {
segmentPath: segmentPath,
focusAndScrollRef: context.focusAndScrollRef,
children: children
});
}
/**
* InnerLayoutRouter handles rendering the provided segment based on the cache.
*/ function InnerLayoutRouter({ tree, segmentPath, debugNameContext, cacheNode: maybeCacheNode, params, url, isActive }) {
const context = (0, _react.useContext)(_approutercontextsharedruntime.GlobalLayoutRouterContext);
const parentNavPromises = (0, _react.useContext)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
if (!context) {
throw Object.defineProperty(new Error('invariant global layout router not mounted'), "__NEXT_ERROR_CODE", {
value: "E473",
enumerable: false,
configurable: true
});
}
const cacheNode = maybeCacheNode !== null ? maybeCacheNode : // This should only be reachable for inactive/hidden segments, during
// prerendering The active segment should always be consistent with the
// CacheNode tree. Regardless, if we don't have a matching CacheNode, we
// must suspend rather than render nothing, to prevent showing an
// inconsistent route.
(0, _react.use)(_unresolvedthenable.unresolvedThenable);
// `rsc` represents the renderable node for this segment.
// If this segment has a `prefetchRsc`, it's the statically prefetched data.
// We should use that on initial render instead of `rsc`. Then we'll switch
// to `rsc` when the dynamic response streams in.
//
// If no prefetch data is available, then we go straight to rendering `rsc`.
const resolvedPrefetchRsc = cacheNode.prefetchRsc !== null ? cacheNode.prefetchRsc : cacheNode.rsc;
// We use `useDeferredValue` to handle switching between the prefetched and
// final values. The second argument is returned on initial render, then it
// re-renders with the first argument.
const rsc = (0, _react.useDeferredValue)(cacheNode.rsc, resolvedPrefetchRsc);
// `rsc` is either a React node or a promise for a React node, except we
// special case `null` to represent that this segment's data is missing. If
// it's a promise, we need to unwrap it so we can determine whether or not the
// data is missing.
let resolvedRsc;
if ((0, _pprnavigations.isDeferredRsc)(rsc)) {
const unwrappedRsc = (0, _react.use)(rsc);
if (unwrappedRsc === null) {
// If the promise was resolved to `null`, it means the data for this
// segment was not returned by the server. Suspend indefinitely. When this
// happens, the router is responsible for triggering a new state update to
// un-suspend this segment.
(0, _react.use)(_unresolvedthenable.unresolvedThenable);
}
resolvedRsc = unwrappedRsc;
} else {
// This is not a deferred RSC promise. Don't need to unwrap it.
if (rsc === null) {
(0, _react.use)(_unresolvedthenable.unresolvedThenable);
}
resolvedRsc = rsc;
}
// In dev, we create a NavigationPromisesContext containing the instrumented promises that provide
// `useSelectedLayoutSegment` and `useSelectedLayoutSegments`.
// Promises are cached outside of render to survive suspense retries.
let navigationPromises = null;
if ("TURBOPACK compile-time truthy", 1) {
const { createNestedLayoutNavigationPromises } = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/navigation-devtools.js [app-client] (ecmascript)");
navigationPromises = createNestedLayoutNavigationPromises(tree, parentNavPromises);
}
let children = resolvedRsc;
if (navigationPromises) {
children = /*#__PURE__*/ (0, _jsxruntime.jsx)(_hooksclientcontextsharedruntime.NavigationPromisesContext.Provider, {
value: navigationPromises,
children: resolvedRsc
});
}
children = /*#__PURE__*/ (0, _jsxruntime.jsx)(_approutercontextsharedruntime.LayoutRouterContext.Provider, {
value: {
parentTree: tree,
parentCacheNode: cacheNode,
parentSegmentPath: segmentPath,
parentParams: params,
debugNameContext: debugNameContext,
// TODO-APP: overriding of url for parallel routes
url: url,
isActive: isActive
},
children: children
});
return children;
}
/**
* Renders suspense boundary with the provided "loading" property as the fallback.
* If no loading property is provided it renders the children without a suspense boundary.
*/ function LoadingBoundary({ name, loading, children }) {
// If loading is a promise, unwrap it. This happens in cases where we haven't
// yet received the loading data from the server — which includes whether or
// not this layout has a loading component at all.
//
// It's OK to suspend here instead of inside the fallback because this
// promise will resolve simultaneously with the data for the segment itself.
// So it will never suspend for longer than it would have if we didn't use
// a Suspense fallback at all.
let loadingModuleData;
if (typeof loading === 'object' && loading !== null && typeof loading.then === 'function') {
const promiseForLoading = loading;
loadingModuleData = (0, _react.use)(promiseForLoading);
} else {
loadingModuleData = loading;
}
if (loadingModuleData) {
const loadingRsc = loadingModuleData[0];
const loadingStyles = loadingModuleData[1];
const loadingScripts = loadingModuleData[2];
return /*#__PURE__*/ (0, _jsxruntime.jsx)(_react.Suspense, {
name: name,
fallback: /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
children: [
loadingStyles,
loadingScripts,
loadingRsc
]
}),
children: children
});
}
return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
children: children
});
}
function OuterLayoutRouter({ parallelRouterKey, error, errorStyles, errorScripts, templateStyles, templateScripts, template, notFound, forbidden, unauthorized, segmentViewBoundaries }) {
const context = (0, _react.useContext)(_approutercontextsharedruntime.LayoutRouterContext);
if (!context) {
throw Object.defineProperty(new Error('invariant expected layout router to be mounted'), "__NEXT_ERROR_CODE", {
value: "E56",
enumerable: false,
configurable: true
});
}
const { parentTree, parentCacheNode, parentSegmentPath, parentParams, url, isActive, debugNameContext } = context;
// Get the CacheNode for this segment by reading it from the parent segment's
// child map.
const parentParallelRoutes = parentCacheNode.parallelRoutes;
let segmentMap = parentParallelRoutes.get(parallelRouterKey);
// If the parallel router cache node does not exist yet, create it.
// This writes to the cache when there is no item in the cache yet. It never *overwrites* existing cache items which is why it's safe in concurrent mode.
if (!segmentMap) {
segmentMap = new Map();
parentParallelRoutes.set(parallelRouterKey, segmentMap);
}
const parentTreeSegment = parentTree[0];
const segmentPath = parentSegmentPath === null ? // the code. We should clean this up.
[
parallelRouterKey
] : parentSegmentPath.concat([
parentTreeSegment,
parallelRouterKey
]);
// The "state" key of a segment is the one passed to React — it represents the
// identity of the UI tree. Whenever the state key changes, the tree is
// recreated and the state is reset. In the App Router model, search params do
// not cause state to be lost, so two segments with the same segment path but
// different search params should have the same state key.
//
// The "cache" key of a segment, however, *does* include the search params, if
// it's possible that the segment accessed the search params on the server.
// (This only applies to page segments; layout segments cannot access search
// params on the server.)
const activeTree = parentTree[1][parallelRouterKey];
if (activeTree === undefined) {
// Could not find a matching segment. The client tree is inconsistent with
// the server tree. Suspend indefinitely; the router will have already
// detected the inconsistency when handling the server response, and
// triggered a refresh of the page to recover.
(0, _react.use)(_unresolvedthenable.unresolvedThenable);
}
const activeSegment = activeTree[0];
const activeStateKey = (0, _createroutercachekey.createRouterCacheKey)(activeSegment, true) // no search params
;
// At each level of the route tree, not only do we render the currently
// active segment — we also render the last N segments that were active at
// this level inside a hidden boundary, to preserve their state
// if or when the user navigates to them again.
//
// bfcacheEntry is a linked list of FlightRouterStates.
let bfcacheEntry = (0, _bfcache.useRouterBFCache)(activeTree, activeStateKey);
let children = [];
do {
const tree = bfcacheEntry.tree;
const stateKey = bfcacheEntry.stateKey;
const segment = tree[0];
const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segment);
// Read segment path from the parallel router cache node.
const cacheNode = segmentMap.get(cacheKey) ?? null;
/*
- Error boundary
- Only renders error boundary if error component is provided.
- Rendered for each segment to ensure they have their own error state.
- When gracefully degrade for bots, skip rendering error boundary.
- Loading boundary
- Only renders suspense boundary if loading components is provided.
- Rendered for each segment to ensure they have their own loading state.
- Passed to the router during rendering to ensure it can be immediately rendered when suspending on a Flight fetch.
*/ let segmentBoundaryTriggerNode = null;
let segmentViewStateNode = null;
if ("TURBOPACK compile-time truthy", 1) {
const { SegmentBoundaryTriggerNode, SegmentViewStateNode } = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/next-devtools/userspace/app/segment-explorer-node.js [app-client] (ecmascript)");
const pagePrefix = (0, _apppaths.normalizeAppPath)(url);
segmentViewStateNode = /*#__PURE__*/ (0, _jsxruntime.jsx)(SegmentViewStateNode, {
page: pagePrefix
}, pagePrefix);
segmentBoundaryTriggerNode = /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
children: /*#__PURE__*/ (0, _jsxruntime.jsx)(SegmentBoundaryTriggerNode, {})
});
}
let params = parentParams;
if (Array.isArray(segment)) {
// This segment contains a route param. Accumulate these as we traverse
// down the router tree. The result represents the set of params that
// the layout/page components are permitted to access below this point.
const paramName = segment[0];
const paramCacheKey = segment[1];
const paramType = segment[2];
const paramValue = (0, _routeparams.getParamValueFromCacheKey)(paramCacheKey, paramType);
if (paramValue !== null) {
params = {
...parentParams,
[paramName]: paramValue
};
}
}
const debugName = getBoundaryDebugNameFromSegment(segment);
// `debugNameContext` represents the nearest non-"virtual" parent segment.
// `getBoundaryDebugNameFromSegment` returns undefined for virtual segments.
// So if `debugName` is undefined, the context is passed through unchanged.
const childDebugNameContext = debugName ?? debugNameContext;
// In practical terms, clicking this name in the Suspense DevTools
// should select the child slots of that layout.
//
// So the name we apply to the Activity boundary is actually based on
// the nearest parent segments.
//
// We skip over "virtual" parents, i.e. ones inserted by Next.js that
// don't correspond to application-defined code.
const isVirtual = debugName === undefined;
const debugNameToDisplay = isVirtual ? undefined : debugNameContext;
// TODO: The loading module data for a segment is stored on the parent, then
// applied to each of that parent segment's parallel route slots. In the
// simple case where there's only one parallel route (the `children` slot),
// this is no different from if the loading module data where stored on the
// child directly. But I'm not sure this actually makes sense when there are
// multiple parallel routes. It's not a huge issue because you always have
// the option to define a narrower loading boundary for a particular slot. But
// this sort of smells like an implementation accident to me.
const loadingModuleData = parentCacheNode.loading;
let child = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_approutercontextsharedruntime.TemplateContext.Provider, {
value: /*#__PURE__*/ (0, _jsxruntime.jsxs)(ScrollAndFocusHandler, {
segmentPath: segmentPath,
children: [
/*#__PURE__*/ (0, _jsxruntime.jsx)(_errorboundary.ErrorBoundary, {
errorComponent: error,
errorStyles: errorStyles,
errorScripts: errorScripts,
children: /*#__PURE__*/ (0, _jsxruntime.jsx)(LoadingBoundary, {
name: debugNameToDisplay,
loading: loadingModuleData,
children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_errorboundary1.HTTPAccessFallbackBoundary, {
notFound: notFound,
forbidden: forbidden,
unauthorized: unauthorized,
children: /*#__PURE__*/ (0, _jsxruntime.jsxs)(_redirectboundary.RedirectBoundary, {
children: [
/*#__PURE__*/ (0, _jsxruntime.jsx)(InnerLayoutRouter, {
url: url,
tree: tree,
params: params,
cacheNode: cacheNode,
segmentPath: segmentPath,
debugNameContext: childDebugNameContext,
isActive: isActive && stateKey === activeStateKey
}),
segmentBoundaryTriggerNode
]
})
})
})
}),
segmentViewStateNode
]
}),
children: [
templateStyles,
templateScripts,
template
]
}, stateKey);
if ("TURBOPACK compile-time truthy", 1) {
const { SegmentStateProvider } = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/next-devtools/userspace/app/segment-explorer-node.js [app-client] (ecmascript)");
child = /*#__PURE__*/ (0, _jsxruntime.jsxs)(SegmentStateProvider, {
children: [
child,
segmentViewBoundaries
]
}, stateKey);
}
if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
;
children.push(child);
bfcacheEntry = bfcacheEntry.next;
}while (bfcacheEntry !== null)
return children;
}
function getBoundaryDebugNameFromSegment(segment) {
if (segment === '/') {
// Reached the root
return '/';
}
if (typeof segment === 'string') {
if (isVirtualLayout(segment)) {
return undefined;
} else {
return segment + '/';
}
}
const paramCacheKey = segment[1];
return paramCacheKey + '/';
}
function isVirtualLayout(segment) {
return(// in a more special way instead of checking the name, to distinguish them
// from app-defined groups.
segment === '(slot)');
}
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
Object.defineProperty(exports.default, '__esModule', {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=layout-router.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/render-from-template-context.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return RenderFromTemplateContext;
}
});
const _interop_require_wildcard = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs [app-client] (ecmascript)");
const _jsxruntime = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)"));
const _approutercontextsharedruntime = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js [app-client] (ecmascript)");
function RenderFromTemplateContext() {
const children = (0, _react.useContext)(_approutercontextsharedruntime.TemplateContext);
return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
children: children
});
}
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
Object.defineProperty(exports.default, '__esModule', {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=render-from-template-context.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/web/spec-extension/adapters/reflect.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "ReflectAdapter", {
enumerable: true,
get: function() {
return ReflectAdapter;
}
});
class ReflectAdapter {
static get(target, prop, receiver) {
const value = Reflect.get(target, prop, receiver);
if (typeof value === 'function') {
return value.bind(target);
}
return value;
}
static set(target, prop, value, receiver) {
return Reflect.set(target, prop, value, receiver);
}
static has(target, prop) {
return Reflect.has(target, prop);
}
static deleteProperty(target, prop) {
return Reflect.deleteProperty(target, prop);
}
} //# sourceMappingURL=reflect.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/utils/reflect-utils.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
// This regex will have fast negatives meaning valid identifiers may not pass
// this test. However this is only used during static generation to provide hints
// about why a page bailed out of some or all prerendering and we can use bracket notation
// for example while `ಠ_ಠ` is a valid identifier it's ok to print `searchParams['ಠ_ಠ']`
// even if this would have been fine too `searchParams.ಠ_ಠ`
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && (module.exports = {
describeHasCheckingStringProperty: null,
describeStringPropertyAccess: null,
wellKnownProperties: null
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
describeHasCheckingStringProperty: function() {
return describeHasCheckingStringProperty;
},
describeStringPropertyAccess: function() {
return describeStringPropertyAccess;
},
wellKnownProperties: function() {
return wellKnownProperties;
}
});
const isDefinitelyAValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
function describeStringPropertyAccess(target, prop) {
if (isDefinitelyAValidIdentifier.test(prop)) {
return `\`${target}.${prop}\``;
}
return `\`${target}[${JSON.stringify(prop)}]\``;
}
function describeHasCheckingStringProperty(target, prop) {
const stringifiedProp = JSON.stringify(prop);
return `\`Reflect.has(${target}, ${stringifiedProp})\`, \`${stringifiedProp} in ${target}\`, or similar`;
}
const wellKnownProperties = new Set([
'hasOwnProperty',
'isPrototypeOf',
'propertyIsEnumerable',
'toString',
'valueOf',
'toLocaleString',
// Promise prototype
'then',
'catch',
'finally',
// React Promise extension
'status',
// 'value',
// 'error',
// React introspection
'displayName',
'_debugInfo',
// Common tested properties
'toJSON',
'$$typeof',
'__esModule'
]); //# sourceMappingURL=reflect-utils.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/request/search-params.browser.dev.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "createRenderSearchParamsFromClient", {
enumerable: true,
get: function() {
return createRenderSearchParamsFromClient;
}
});
const _reflect = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/web/spec-extension/adapters/reflect.js [app-client] (ecmascript)");
const _reflectutils = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/utils/reflect-utils.js [app-client] (ecmascript)");
const CachedSearchParams = new WeakMap();
function makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams) {
const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
if (cachedSearchParams) {
return cachedSearchParams;
}
const proxiedProperties = new Set();
const promise = Promise.resolve(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
} 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(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(expression);
}
}
return Reflect.has(target, prop);
},
ownKeys (target) {
warnForSyncSpread();
return Reflect.ownKeys(target);
}
});
CachedSearchParams.set(underlyingSearchParams, proxiedPromise);
return proxiedPromise;
}
function warnForSyncAccess(expression) {
console.error(`A searchParam property was accessed directly with ${expression}. ` + `\`searchParams\` is a Promise and must be unwrapped with \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
}
function warnForSyncSpread() {
console.error(`The keys of \`searchParams\` were accessed directly. ` + `\`searchParams\` is a Promise and must be unwrapped with \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
}
function createRenderSearchParamsFromClient(underlyingSearchParams) {
return makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams);
}
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
Object.defineProperty(exports.default, '__esModule', {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=search-params.browser.dev.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/request/search-params.browser.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$00__$2d$__projet$2f$plumeia$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "createRenderSearchParamsFromClient", {
enumerable: true,
get: function() {
return createRenderSearchParamsFromClient;
}
});
const createRenderSearchParamsFromClient = ("TURBOPACK compile-time truthy", 1) ? __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/request/search-params.browser.dev.js [app-client] (ecmascript)").createRenderSearchParamsFromClient : "TURBOPACK unreachable";
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
Object.defineProperty(exports.default, '__esModule', {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=search-params.browser.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/request/params.browser.dev.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "createRenderParamsFromClient", {
enumerable: true,
get: function() {
return createRenderParamsFromClient;
}
});
const _reflect = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/web/spec-extension/adapters/reflect.js [app-client] (ecmascript)");
const _reflectutils = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/utils/reflect-utils.js [app-client] (ecmascript)");
const CachedParams = new WeakMap();
function makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams) {
const cachedParams = CachedParams.get(underlyingParams);
if (cachedParams) {
return cachedParams;
}
// 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(underlyingParams);
const proxiedProperties = new Set();
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 {
proxiedProperties.add(prop);
}
});
const proxiedPromise = new Proxy(promise, {
get (target, prop, receiver) {
if (typeof prop === 'string') {
if (proxiedProperties.has(prop)) {
const expression = (0, _reflectutils.describeStringPropertyAccess)('params', prop);
warnForSyncAccess(expression);
}
}
return _reflect.ReflectAdapter.get(target, prop, receiver);
},
set (target, prop, value, receiver) {
if (typeof prop === 'string') {
proxiedProperties.delete(prop);
}
return _reflect.ReflectAdapter.set(target, prop, value, receiver);
},
ownKeys (target) {
warnForEnumeration();
return Reflect.ownKeys(target);
}
});
CachedParams.set(underlyingParams, proxiedPromise);
return proxiedPromise;
}
function warnForSyncAccess(expression) {
console.error(`A param property was accessed directly with ${expression}. ` + `\`params\` is a Promise and must be unwrapped with \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
}
function warnForEnumeration() {
console.error(`params are being enumerated. ` + `\`params\` is a Promise and must be unwrapped with \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
}
function createRenderParamsFromClient(clientParams) {
return makeDynamicallyTrackedParamsWithDevWarnings(clientParams);
}
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
Object.defineProperty(exports.default, '__esModule', {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=params.browser.dev.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/request/params.browser.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$00__$2d$__projet$2f$plumeia$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "createRenderParamsFromClient", {
enumerable: true,
get: function() {
return createRenderParamsFromClient;
}
});
const createRenderParamsFromClient = ("TURBOPACK compile-time truthy", 1) ? __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/request/params.browser.dev.js [app-client] (ecmascript)").createRenderParamsFromClient : "TURBOPACK unreachable";
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
Object.defineProperty(exports.default, '__esModule', {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=params.browser.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$00__$2d$__projet$2f$plumeia$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "createDedupedByCallsiteServerErrorLoggerDev", {
enumerable: true,
get: function() {
return createDedupedByCallsiteServerErrorLoggerDev;
}
});
const _react = /*#__PURE__*/ _interop_require_wildcard(__turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)"));
function _getRequireWildcardCache(nodeInterop) {
if (typeof WeakMap !== "function") return null;
var cacheBabelInterop = new WeakMap();
var cacheNodeInterop = new WeakMap();
return (_getRequireWildcardCache = function(nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
})(nodeInterop);
}
function _interop_require_wildcard(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj;
}
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
return {
default: obj
};
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj);
}
var newObj = {
__proto__: null
};
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
for(var key in obj){
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
if (desc && (desc.get || desc.set)) {
Object.defineProperty(newObj, key, desc);
} else {
newObj[key] = obj[key];
}
}
}
newObj.default = obj;
if (cache) {
cache.set(obj, newObj);
}
return newObj;
}
const errorRef = {
current: null
};
// React.cache is currently only available in canary/experimental React channels.
const cache = typeof _react.cache === 'function' ? _react.cache : (fn)=>fn;
// When Cache Components is enabled, we record these as errors so that they
// are captured by the dev overlay as it's more critical to fix these
// when enabled.
const logErrorOrWarn = ("TURBOPACK compile-time falsy", 0) ? "TURBOPACK unreachable" : console.warn;
// We don't want to dedupe across requests.
// The developer might've just attempted to fix the warning so we should warn again if it still happens.
const flushCurrentErrorIfNew = cache((key)=>{
try {
logErrorOrWarn(errorRef.current);
} finally{
errorRef.current = null;
}
});
function createDedupedByCallsiteServerErrorLoggerDev(getMessage) {
return function logDedupedError(...args) {
const message = getMessage(...args);
if ("TURBOPACK compile-time truthy", 1) {
var _stack;
const callStackFrames = (_stack = new Error().stack) == null ? void 0 : _stack.split('\n');
if (callStackFrames === undefined || callStackFrames.length < 4) {
logErrorOrWarn(message);
} else {
// Error:
// logDedupedError
// asyncApiBeingAccessedSynchronously
//
// TODO: This breaks if sourcemaps with ignore lists are enabled.
const key = callStackFrames[4];
errorRef.current = message;
flushCurrentErrorIfNew(key);
}
} else //TURBOPACK unreachable
;
};
} //# sourceMappingURL=create-deduped-by-callsite-server-error-logger.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/after-task-async-storage-instance.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "afterTaskAsyncStorageInstance", {
enumerable: true,
get: function() {
return afterTaskAsyncStorageInstance;
}
});
const _asynclocalstorage = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/async-local-storage.js [app-client] (ecmascript)");
const afterTaskAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)(); //# sourceMappingURL=after-task-async-storage-instance.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/after-task-async-storage.external.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "afterTaskAsyncStorage", {
enumerable: true,
get: function() {
return _aftertaskasyncstorageinstance.afterTaskAsyncStorageInstance;
}
});
const _aftertaskasyncstorageinstance = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/after-task-async-storage-instance.js [app-client] (ecmascript)"); //# sourceMappingURL=after-task-async-storage.external.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/request/utils.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && (module.exports = {
isRequestAPICallableInsideAfter: null,
throwForSearchParamsAccessInUseCache: null,
throwWithStaticGenerationBailoutErrorWithDynamicError: null
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
isRequestAPICallableInsideAfter: function() {
return isRequestAPICallableInsideAfter;
},
throwForSearchParamsAccessInUseCache: function() {
return throwForSearchParamsAccessInUseCache;
},
throwWithStaticGenerationBailoutErrorWithDynamicError: function() {
return throwWithStaticGenerationBailoutErrorWithDynamicError;
}
});
const _staticgenerationbailout = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/static-generation-bailout.js [app-client] (ecmascript)");
const _aftertaskasyncstorageexternal = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/after-task-async-storage.external.js [app-client] (ecmascript)");
function throwWithStaticGenerationBailoutErrorWithDynamicError(route, expression) {
throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${route} with \`dynamic = "error"\` couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
value: "E543",
enumerable: false,
configurable: true
});
}
function throwForSearchParamsAccessInUseCache(workStore, constructorOpt) {
const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`searchParams\` inside "use cache". Accessing dynamic request data inside a cache scope is not supported. If you need some search params inside a cached function await \`searchParams\` outside of the cached function and pass only the required search params as arguments to the cached function. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
value: "E842",
enumerable: false,
configurable: true
});
Error.captureStackTrace(error, constructorOpt);
workStore.invalidDynamicUsageError ??= error;
throw error;
}
function isRequestAPICallableInsideAfter() {
const afterTaskStore = _aftertaskasyncstorageexternal.afterTaskAsyncStorage.getStore();
return (afterTaskStore == null ? void 0 : afterTaskStore.rootTaskSpawnPhase) === 'action';
} //# sourceMappingURL=utils.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/staged-rendering.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && (module.exports = {
RenderStage: null,
StagedRenderingController: null
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
RenderStage: function() {
return RenderStage;
},
StagedRenderingController: function() {
return StagedRenderingController;
}
});
const _invarianterror = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/invariant-error.js [app-client] (ecmascript)");
const _promisewithresolvers = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/promise-with-resolvers.js [app-client] (ecmascript)");
var RenderStage = /*#__PURE__*/ function(RenderStage) {
RenderStage[RenderStage["Before"] = 1] = "Before";
RenderStage[RenderStage["Static"] = 2] = "Static";
RenderStage[RenderStage["Runtime"] = 3] = "Runtime";
RenderStage[RenderStage["Dynamic"] = 4] = "Dynamic";
RenderStage[RenderStage["Abandoned"] = 5] = "Abandoned";
return RenderStage;
}({});
class StagedRenderingController {
constructor(abortSignal = null, hasRuntimePrefetch){
this.abortSignal = abortSignal;
this.hasRuntimePrefetch = hasRuntimePrefetch;
this.currentStage = 1;
this.staticInterruptReason = null;
this.runtimeInterruptReason = null;
this.staticStageEndTime = Infinity;
this.runtimeStageEndTime = Infinity;
this.runtimeStageListeners = [];
this.dynamicStageListeners = [];
this.runtimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
this.dynamicStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
this.mayAbandon = false;
if (abortSignal) {
abortSignal.addEventListener('abort', ()=>{
const { reason } = abortSignal;
if (this.currentStage < 3) {
this.runtimeStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
;
this.runtimeStagePromise.reject(reason);
}
if (this.currentStage < 4 || this.currentStage === 5) {
this.dynamicStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
;
this.dynamicStagePromise.reject(reason);
}
}, {
once: true
});
this.mayAbandon = true;
}
}
onStage(stage, callback) {
if (this.currentStage >= stage) {
callback();
} else if (stage === 3) {
this.runtimeStageListeners.push(callback);
} else if (stage === 4) {
this.dynamicStageListeners.push(callback);
} else {
// This should never happen
throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
value: "E881",
enumerable: false,
configurable: true
});
}
}
canSyncInterrupt() {
// If we haven't started the render yet, it can't be interrupted.
if (this.currentStage === 1) {
return false;
}
const boundaryStage = this.hasRuntimePrefetch ? 4 : 3;
return this.currentStage < boundaryStage;
}
syncInterruptCurrentStageWithReason(reason) {
if (this.currentStage === 1) {
return;
}
// If Sync IO occurs during the initial (abandonable) render, we'll retry it,
// so we want a slightly different flow.
// See the implementation of `abandonRenderImpl` for more explanation.
if (this.mayAbandon) {
return this.abandonRenderImpl();
}
// If we're in the final render, we cannot abandon it. We need to advance to the Dynamic stage
// and capture the interruption reason.
switch(this.currentStage){
case 2:
{
this.staticInterruptReason = reason;
this.advanceStage(4);
return;
}
case 3:
{
// We only error for Sync IO in the runtime stage if the route
// is configured to use runtime prefetching.
// We do this to reflect the fact that during a runtime prefetch,
// Sync IO aborts aborts the render.
// Note that `canSyncInterrupt` should prevent us from getting here at all
// if runtime prefetching isn't enabled.
if (this.hasRuntimePrefetch) {
this.runtimeInterruptReason = reason;
this.advanceStage(4);
}
return;
}
case 4:
case 5:
default:
}
}
getStaticInterruptReason() {
return this.staticInterruptReason;
}
getRuntimeInterruptReason() {
return this.runtimeInterruptReason;
}
getStaticStageEndTime() {
return this.staticStageEndTime;
}
getRuntimeStageEndTime() {
return this.runtimeStageEndTime;
}
abandonRender() {
if (!this.mayAbandon) {
throw Object.defineProperty(new _invarianterror.InvariantError('`abandonRender` called on a stage controller that cannot be abandoned.'), "__NEXT_ERROR_CODE", {
value: "E938",
enumerable: false,
configurable: true
});
}
this.abandonRenderImpl();
}
abandonRenderImpl() {
// In staged rendering, only the initial render is abandonable.
// We can abandon the initial render if
// 1. We notice a cache miss, and need to wait for caches to fill
// 2. A sync IO error occurs, and the render should be interrupted
// (this might be a lazy intitialization of a module,
// so we still want to restart in this case and see if it still occurs)
// In either case, we'll be doing another render after this one,
// so we only want to unblock the Runtime stage, not Dynamic, because
// unblocking the dynamic stage would likely lead to wasted (uncached) IO.
const { currentStage } = this;
switch(currentStage){
case 2:
{
this.currentStage = 5;
this.resolveRuntimeStage();
return;
}
case 3:
{
this.currentStage = 5;
return;
}
case 4:
case 1:
case 5:
break;
default:
{
currentStage;
}
}
}
advanceStage(stage) {
// If we're already at the target stage or beyond, do nothing.
// (this can happen e.g. if sync IO advanced us to the dynamic stage)
if (stage <= this.currentStage) {
return;
}
let currentStage = this.currentStage;
this.currentStage = stage;
if (currentStage < 3 && stage >= 3) {
this.staticStageEndTime = performance.now() + performance.timeOrigin;
this.resolveRuntimeStage();
}
if (currentStage < 4 && stage >= 4) {
this.runtimeStageEndTime = performance.now() + performance.timeOrigin;
this.resolveDynamicStage();
return;
}
}
/** Fire the `onStage` listeners for the runtime stage and unblock any promises waiting for it. */ resolveRuntimeStage() {
const runtimeListeners = this.runtimeStageListeners;
for(let i = 0; i < runtimeListeners.length; i++){
runtimeListeners[i]();
}
runtimeListeners.length = 0;
this.runtimeStagePromise.resolve();
}
/** Fire the `onStage` listeners for the dynamic stage and unblock any promises waiting for it. */ resolveDynamicStage() {
const dynamicListeners = this.dynamicStageListeners;
for(let i = 0; i < dynamicListeners.length; i++){
dynamicListeners[i]();
}
dynamicListeners.length = 0;
this.dynamicStagePromise.resolve();
}
getStagePromise(stage) {
switch(stage){
case 3:
{
return this.runtimeStagePromise.promise;
}
case 4:
{
return this.dynamicStagePromise.promise;
}
default:
{
stage;
throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
value: "E881",
enumerable: false,
configurable: true
});
}
}
}
waitForStage(stage) {
return this.getStagePromise(stage);
}
delayUntilStage(stage, displayName, resolvedValue) {
const ioTriggerPromise = this.getStagePromise(stage);
const promise = makeDevtoolsIOPromiseFromIOTrigger(ioTriggerPromise, displayName, resolvedValue);
// Analogously to `makeHangingPromise`, we might reject this promise if the signal is invoked.
// (e.g. in the case where we don't want want the render to proceed to the dynamic stage and abort it).
// We shouldn't consider this an unhandled rejection, so we attach a noop catch handler here to suppress this warning.
if (this.abortSignal) {
promise.catch(ignoreReject);
}
return promise;
}
}
function ignoreReject() {}
// TODO(restart-on-cache-miss): the layering of `delayUntilStage`,
// `makeDevtoolsIOPromiseFromIOTrigger` and and `makeDevtoolsIOAwarePromise`
// is confusing, we should clean it up.
function makeDevtoolsIOPromiseFromIOTrigger(ioTrigger, displayName, resolvedValue) {
// If we create a `new Promise` and give it a displayName
// (with no userspace code above us in the stack)
// React Devtools will use it as the IO cause when determining "suspended by".
// In particular, it should shadow any inner IO that resolved/rejected the promise
// (in case of staged rendering, this will be the `setTimeout` that triggers the relevant stage)
const promise = new Promise((resolve, reject)=>{
ioTrigger.then(resolve.bind(null, resolvedValue), reject);
});
if (displayName !== undefined) {
// @ts-expect-error
promise.displayName = displayName;
}
return promise;
} //# sourceMappingURL=staged-rendering.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/request/search-params.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$00__$2d$__projet$2f$plumeia$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
"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 = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/web/spec-extension/adapters/reflect.js [app-client] (ecmascript)");
const _dynamicrendering = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/dynamic-rendering.js [app-client] (ecmascript)");
const _workunitasyncstorageexternal = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/work-unit-async-storage.external.js [app-client] (ecmascript)");
const _invarianterror = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/invariant-error.js [app-client] (ecmascript)");
const _dynamicrenderingutils = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/dynamic-rendering-utils.js [app-client] (ecmascript)");
const _creatededupedbycallsiteservererrorlogger = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js [app-client] (ecmascript)");
const _reflectutils = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/utils/reflect-utils.js [app-client] (ecmascript)");
const _utils = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/request/utils.js [app-client] (ecmascript)");
const _stagedrendering = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/staged-rendering.js [app-client] (ecmascript)");
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, workUnitStore);
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, workUnitStore);
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 makeErroringSearchParams(workStore, prerenderStore);
default:
return prerenderStore;
}
}
function createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore) {
return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, makeUntrackedSearchParams(underlyingSearchParams));
}
function createRenderSearchParams(underlyingSearchParams, workStore, requestStore) {
if (workStore.forceStatic) {
// When using forceStatic we override all other logic and always just return an empty
// dictionary object.
return Promise.resolve({});
} else {
if ("TURBOPACK compile-time truthy", 1) {
// 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 makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore);
} else //TURBOPACK unreachable
;
}
}
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 makeErroringSearchParams(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);
}
if (typeof prop === 'string' && prop === '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 _reflect.ReflectAdapter.get(target, prop, receiver);
}
});
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);
}
});
CachedSearchParamsForUseCache.set(workStore, proxiedPromise);
return proxiedPromise;
}
function makeUntrackedSearchParams(underlyingSearchParams) {
const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
if (cachedSearchParams) {
return cachedSearchParams;
}
const promise = Promise.resolve(underlyingSearchParams);
CachedSearchParams.set(underlyingSearchParams, promise);
return promise;
}
function makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore) {
if (requestStore.asyncApiPromises) {
// Do not cache the resulting promise. If we do, we'll only show the first "awaited at"
// across all segments that receive searchParams.
return makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore);
} else {
const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
if (cachedSearchParams) {
return cachedSearchParams;
}
const promise = makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore);
CachedSearchParams.set(requestStore, promise);
return promise;
}
}
function makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore) {
const promiseInitialized = {
current: false
};
const proxiedUnderlying = instrumentSearchParamsObjectWithDevWarnings(underlyingSearchParams, workStore, promiseInitialized);
let promise;
if (requestStore.asyncApiPromises) {
// We wrap each instance of searchParams in a `new Promise()`.
// This is important when all awaits are in third party which would otherwise
// track all the way to the internal params.
const sharedSearchParamsParent = requestStore.asyncApiPromises.sharedSearchParamsParent;
promise = new Promise((resolve, reject)=>{
sharedSearchParamsParent.then(()=>resolve(proxiedUnderlying), reject);
});
// @ts-expect-error
promise.displayName = 'searchParams';
} else {
promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(proxiedUnderlying, requestStore, _stagedrendering.RenderStage.Runtime);
}
promise.then(()=>{
promiseInitialized.current = true;
}, // is aborted before it can reach the runtime stage.
// In that case, we have to prevent an unhandled rejection from the promise
// created by this `.then()` call.
// This does not affect the `promiseInitialized` logic above,
// because `proxiedUnderlying` will not be used to resolve the promise,
// so there's no risk of any of its properties being accessed and triggering
// an undesireable warning.
ignoreReject);
return instrumentSearchParamsPromiseWithDevWarnings(underlyingSearchParams, promise, workStore);
}
function ignoreReject() {}
function instrumentSearchParamsObjectWithDevWarnings(underlyingSearchParams, workStore, promiseInitialized) {
// 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.
return new Proxy(underlyingSearchParams, {
get (target, prop, receiver) {
if (typeof prop === 'string' && promiseInitialized.current) {
if (workStore.dynamicShouldError) {
const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', prop);
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
}
}
return _reflect.ReflectAdapter.get(target, prop, receiver);
},
has (target, prop) {
if (typeof prop === 'string') {
if (workStore.dynamicShouldError) {
const expression = (0, _reflectutils.describeHasCheckingStringProperty)('searchParams', prop);
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
}
}
return Reflect.has(target, prop);
},
ownKeys (target) {
if (workStore.dynamicShouldError) {
const expression = '`{...searchParams}`, `Object.keys(searchParams)`, or similar';
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
}
return Reflect.ownKeys(target);
}
});
}
function instrumentSearchParamsPromiseWithDevWarnings(underlyingSearchParams, promise, workStore) {
// Track which properties we should warn for.
const proxiedProperties = new Set();
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
} else {
proxiedProperties.add(prop);
}
});
return new Proxy(promise, {
get (target, prop, receiver) {
if (prop === 'then' && workStore.dynamicShouldError) {
const expression = '`searchParams.then`';
(0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.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);
warnForSyncAccess(workStore.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(workStore.route, expression);
}
}
return Reflect.has(target, prop);
},
ownKeys (target) {
const expression = '`Object.keys(searchParams)` or similar';
warnForSyncAccess(workStore.route, expression);
return Reflect.ownKeys(target);
}
});
}
const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createSearchAccessError);
function createSearchAccessError(route, expression) {
const prefix = route ? `Route "${route}" ` : 'This route ';
return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`searchParams\` is 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: "E848",
enumerable: false,
configurable: true
});
} //# sourceMappingURL=search-params.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/dynamic-access-async-storage-instance.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "dynamicAccessAsyncStorageInstance", {
enumerable: true,
get: function() {
return dynamicAccessAsyncStorageInstance;
}
});
const _asynclocalstorage = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/async-local-storage.js [app-client] (ecmascript)");
const dynamicAccessAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)(); //# sourceMappingURL=dynamic-access-async-storage-instance.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/dynamic-access-async-storage.external.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "dynamicAccessAsyncStorage", {
enumerable: true,
get: function() {
return _dynamicaccessasyncstorageinstance.dynamicAccessAsyncStorageInstance;
}
});
const _dynamicaccessasyncstorageinstance = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/dynamic-access-async-storage-instance.js [app-client] (ecmascript)"); //# sourceMappingURL=dynamic-access-async-storage.external.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/request/params.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$00__$2d$__projet$2f$plumeia$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && (module.exports = {
createParamsFromClient: null,
createPrerenderParamsForClientSegment: null,
createServerParamsForMetadata: null,
createServerParamsForRoute: null,
createServerParamsForServerSegment: null
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
createParamsFromClient: function() {
return createParamsFromClient;
},
createPrerenderParamsForClientSegment: function() {
return createPrerenderParamsForClientSegment;
},
createServerParamsForMetadata: function() {
return createServerParamsForMetadata;
},
createServerParamsForRoute: function() {
return createServerParamsForRoute;
},
createServerParamsForServerSegment: function() {
return createServerParamsForServerSegment;
}
});
const _workasyncstorageexternal = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/work-async-storage.external.js [app-client] (ecmascript)");
const _reflect = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/web/spec-extension/adapters/reflect.js [app-client] (ecmascript)");
const _dynamicrendering = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/dynamic-rendering.js [app-client] (ecmascript)");
const _workunitasyncstorageexternal = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/work-unit-async-storage.external.js [app-client] (ecmascript)");
const _invarianterror = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/invariant-error.js [app-client] (ecmascript)");
const _reflectutils = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/utils/reflect-utils.js [app-client] (ecmascript)");
const _dynamicrenderingutils = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/dynamic-rendering-utils.js [app-client] (ecmascript)");
const _creatededupedbycallsiteservererrorlogger = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js [app-client] (ecmascript)");
const _dynamicaccessasyncstorageexternal = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/dynamic-access-async-storage.external.js [app-client] (ecmascript)");
const _stagedrendering = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/staged-rendering.js [app-client] (ecmascript)");
function createParamsFromClient(underlyingParams, workStore) {
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
if (workUnitStore) {
switch(workUnitStore.type){
case 'prerender':
case 'prerender-client':
case 'prerender-ppr':
case 'prerender-legacy':
return createStaticPrerenderParams(underlyingParams, workStore, workUnitStore);
case 'cache':
case 'private-cache':
case 'unstable-cache':
throw Object.defineProperty(new _invarianterror.InvariantError('createParamsFromClient should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
value: "E736",
enumerable: false,
configurable: true
});
case 'prerender-runtime':
throw Object.defineProperty(new _invarianterror.InvariantError('createParamsFromClient should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
value: "E770",
enumerable: false,
configurable: true
});
case 'request':
if ("TURBOPACK compile-time truthy", 1) {
// 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.
const devFallbackParams = workUnitStore.devFallbackParams;
return createRenderParamsInDev(underlyingParams, devFallbackParams, workStore, workUnitStore);
} else //TURBOPACK unreachable
;
default:
workUnitStore;
}
}
(0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
}
const createServerParamsForMetadata = createServerParamsForServerSegment;
function createServerParamsForRoute(underlyingParams, workStore) {
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
if (workUnitStore) {
switch(workUnitStore.type){
case 'prerender':
case 'prerender-client':
case 'prerender-ppr':
case 'prerender-legacy':
return createStaticPrerenderParams(underlyingParams, workStore, workUnitStore);
case 'cache':
case 'private-cache':
case 'unstable-cache':
throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForRoute should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
value: "E738",
enumerable: false,
configurable: true
});
case 'prerender-runtime':
return createRuntimePrerenderParams(underlyingParams, workUnitStore);
case 'request':
if ("TURBOPACK compile-time truthy", 1) {
// 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.
const devFallbackParams = workUnitStore.devFallbackParams;
return createRenderParamsInDev(underlyingParams, devFallbackParams, workStore, workUnitStore);
} else //TURBOPACK unreachable
;
default:
workUnitStore;
}
}
(0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
}
function createServerParamsForServerSegment(underlyingParams, workStore) {
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
if (workUnitStore) {
switch(workUnitStore.type){
case 'prerender':
case 'prerender-client':
case 'prerender-ppr':
case 'prerender-legacy':
return createStaticPrerenderParams(underlyingParams, workStore, workUnitStore);
case 'cache':
case 'private-cache':
case 'unstable-cache':
throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForServerSegment should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
value: "E743",
enumerable: false,
configurable: true
});
case 'prerender-runtime':
return createRuntimePrerenderParams(underlyingParams, workUnitStore);
case 'request':
if ("TURBOPACK compile-time truthy", 1) {
// 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.
const devFallbackParams = workUnitStore.devFallbackParams;
return createRenderParamsInDev(underlyingParams, devFallbackParams, workStore, workUnitStore);
} else //TURBOPACK unreachable
;
default:
workUnitStore;
}
}
(0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
}
function createPrerenderParamsForClientSegment(underlyingParams) {
const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
if (!workStore) {
throw Object.defineProperty(new _invarianterror.InvariantError('Missing workStore in createPrerenderParamsForClientSegment'), "__NEXT_ERROR_CODE", {
value: "E773",
enumerable: false,
configurable: true
});
}
const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
if (workUnitStore) {
switch(workUnitStore.type){
case 'prerender':
case 'prerender-client':
const fallbackParams = workUnitStore.fallbackRouteParams;
if (fallbackParams) {
for(let key in underlyingParams){
if (fallbackParams.has(key)) {
// This params object has one or more fallback params, so we need
// to consider the awaiting of this params object "dynamic". Since
// we are in cacheComponents mode we encode this as a promise that never
// resolves.
return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`params`');
}
}
}
break;
case 'cache':
case 'private-cache':
case 'unstable-cache':
throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderParamsForClientSegment should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
value: "E734",
enumerable: false,
configurable: true
});
case 'prerender-ppr':
case 'prerender-legacy':
case 'prerender-runtime':
case 'request':
break;
default:
workUnitStore;
}
}
// We're prerendering in a mode that does not abort. 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(underlyingParams);
}
function createStaticPrerenderParams(underlyingParams, workStore, prerenderStore) {
switch(prerenderStore.type){
case 'prerender':
case 'prerender-client':
{
const fallbackParams = prerenderStore.fallbackRouteParams;
if (fallbackParams) {
for(const key in underlyingParams){
if (fallbackParams.has(key)) {
// This params object has one or more fallback params, so we need
// to consider the awaiting of this params object "dynamic". Since
// we are in cacheComponents mode we encode this as a promise that never
// resolves.
return makeHangingParams(underlyingParams, workStore, prerenderStore);
}
}
}
break;
}
case 'prerender-ppr':
{
const fallbackParams = prerenderStore.fallbackRouteParams;
if (fallbackParams) {
for(const key in underlyingParams){
if (fallbackParams.has(key)) {
return makeErroringParams(underlyingParams, fallbackParams, workStore, prerenderStore);
}
}
}
break;
}
case 'prerender-legacy':
break;
default:
prerenderStore;
}
return makeUntrackedParams(underlyingParams);
}
function createRuntimePrerenderParams(underlyingParams, workUnitStore) {
return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, makeUntrackedParams(underlyingParams));
}
function createRenderParamsInProd(underlyingParams) {
return makeUntrackedParams(underlyingParams);
}
function createRenderParamsInDev(underlyingParams, devFallbackParams, workStore, requestStore) {
let hasFallbackParams = false;
if (devFallbackParams) {
for(let key in underlyingParams){
if (devFallbackParams.has(key)) {
hasFallbackParams = true;
break;
}
}
}
return makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, hasFallbackParams, workStore, requestStore);
}
const CachedParams = new WeakMap();
const fallbackParamsProxyHandler = {
get: function get(target, prop, receiver) {
if (prop === 'then' || prop === 'catch' || prop === 'finally') {
const originalMethod = _reflect.ReflectAdapter.get(target, prop, receiver);
return ({
[prop]: (...args)=>{
const store = _dynamicaccessasyncstorageexternal.dynamicAccessAsyncStorage.getStore();
if (store) {
store.abortController.abort(Object.defineProperty(new Error(`Accessed fallback \`params\` during prerendering.`), "__NEXT_ERROR_CODE", {
value: "E691",
enumerable: false,
configurable: true
}));
}
return new Proxy(originalMethod.apply(target, args), fallbackParamsProxyHandler);
}
})[prop];
}
return _reflect.ReflectAdapter.get(target, prop, receiver);
}
};
function makeHangingParams(underlyingParams, workStore, prerenderStore) {
const cachedParams = CachedParams.get(underlyingParams);
if (cachedParams) {
return cachedParams;
}
const promise = new Proxy((0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`params`'), fallbackParamsProxyHandler);
CachedParams.set(underlyingParams, promise);
return promise;
}
function makeErroringParams(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)('params', 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
});
}
}
});
return promise;
}
function makeUntrackedParams(underlyingParams) {
const cachedParams = CachedParams.get(underlyingParams);
if (cachedParams) {
return cachedParams;
}
const promise = Promise.resolve(underlyingParams);
CachedParams.set(underlyingParams, promise);
return promise;
}
function makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, hasFallbackParams, workStore, requestStore) {
if (requestStore.asyncApiPromises && hasFallbackParams) {
// We wrap each instance of params in a `new Promise()`, because deduping
// them across requests doesn't work anyway and this let us show each
// await a different set of values. This is important when all awaits
// are in third party which would otherwise track all the way to the
// internal params.
const sharedParamsParent = requestStore.asyncApiPromises.sharedParamsParent;
const promise = new Promise((resolve, reject)=>{
sharedParamsParent.then(()=>resolve(underlyingParams), reject);
});
// @ts-expect-error
promise.displayName = 'params';
return instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore);
}
const cachedParams = CachedParams.get(underlyingParams);
if (cachedParams) {
return cachedParams;
}
// 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 = hasFallbackParams ? (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingParams, requestStore, _stagedrendering.RenderStage.Runtime) : Promise.resolve(underlyingParams);
const proxiedPromise = instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore);
CachedParams.set(underlyingParams, proxiedPromise);
return proxiedPromise;
}
function instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore) {
// Track which properties we should warn for.
const proxiedProperties = new Set();
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 {
proxiedProperties.add(prop);
}
});
return new Proxy(promise, {
get (target, prop, receiver) {
if (typeof prop === 'string') {
if (proxiedProperties.has(prop)) {
const expression = (0, _reflectutils.describeStringPropertyAccess)('params', prop);
warnForSyncAccess(workStore.route, expression);
}
}
return _reflect.ReflectAdapter.get(target, prop, receiver);
},
set (target, prop, value, receiver) {
if (typeof prop === 'string') {
proxiedProperties.delete(prop);
}
return _reflect.ReflectAdapter.set(target, prop, value, receiver);
},
ownKeys (target) {
const expression = '`...params` or similar expression';
warnForSyncAccess(workStore.route, expression);
return Reflect.ownKeys(target);
}
});
}
const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createParamsAccessError);
function createParamsAccessError(route, expression) {
const prefix = route ? `Route "${route}" ` : 'This route ';
return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`params\` is 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: "E834",
enumerable: false,
configurable: true
});
} //# sourceMappingURL=params.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/client-page.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "ClientPageRoot", {
enumerable: true,
get: function() {
return ClientPageRoot;
}
});
const _jsxruntime = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
const _invarianterror = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/invariant-error.js [app-client] (ecmascript)");
const _approutercontextsharedruntime = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js [app-client] (ecmascript)");
const _react = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)");
const _routeparams = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/route-params.js [app-client] (ecmascript)");
const _hooksclientcontextsharedruntime = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.js [app-client] (ecmascript)");
function ClientPageRoot({ Component, serverProvidedParams }) {
let searchParams;
let params;
if (serverProvidedParams !== null) {
searchParams = serverProvidedParams.searchParams;
params = serverProvidedParams.params;
} else {
// When Cache Components is enabled, the server does not pass the params as
// props; they are parsed on the client and passed via context.
const layoutRouterContext = (0, _react.use)(_approutercontextsharedruntime.LayoutRouterContext);
params = layoutRouterContext !== null ? layoutRouterContext.parentParams : {};
// This is an intentional behavior change: when Cache Components is enabled,
// client segments receive the "canonical" search params, not the
// rewritten ones. Users should either call useSearchParams directly or pass
// the rewritten ones in from a Server Component.
// TODO: Log a deprecation error when this object is accessed
searchParams = (0, _routeparams.urlSearchParamsToParsedUrlQuery)((0, _react.use)(_hooksclientcontextsharedruntime.SearchParamsContext));
}
if (typeof window === 'undefined') {
const { workAsyncStorage } = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/work-async-storage.external.js [app-client] (ecmascript)");
let clientSearchParams;
let clientParams;
// We are going to instrument the searchParams prop with tracking for the
// appropriate context. We wrap differently in prerendering vs rendering
const store = workAsyncStorage.getStore();
if (!store) {
throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to exist when handling searchParams in a client Page.'), "__NEXT_ERROR_CODE", {
value: "E564",
enumerable: false,
configurable: true
});
}
const { createSearchParamsFromClient } = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/request/search-params.js [app-client] (ecmascript)");
clientSearchParams = createSearchParamsFromClient(searchParams, store);
const { createParamsFromClient } = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/request/params.js [app-client] (ecmascript)");
clientParams = createParamsFromClient(params, store);
return /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
params: clientParams,
searchParams: clientSearchParams
});
} else {
const { createRenderSearchParamsFromClient } = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/request/search-params.browser.js [app-client] (ecmascript)");
const clientSearchParams = createRenderSearchParamsFromClient(searchParams);
const { createRenderParamsFromClient } = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/request/params.browser.js [app-client] (ecmascript)");
const clientParams = createRenderParamsFromClient(params);
return /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
params: clientParams,
searchParams: clientSearchParams
});
}
}
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
Object.defineProperty(exports.default, '__esModule', {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=client-page.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/components/client-segment.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "ClientSegmentRoot", {
enumerable: true,
get: function() {
return ClientSegmentRoot;
}
});
const _jsxruntime = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
const _invarianterror = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/invariant-error.js [app-client] (ecmascript)");
const _approutercontextsharedruntime = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js [app-client] (ecmascript)");
const _react = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)");
function ClientSegmentRoot({ Component, slots, serverProvidedParams }) {
let params;
if (serverProvidedParams !== null) {
params = serverProvidedParams.params;
} else {
// When Cache Components is enabled, the server does not pass the params
// as props; they are parsed on the client and passed via context.
const layoutRouterContext = (0, _react.use)(_approutercontextsharedruntime.LayoutRouterContext);
params = layoutRouterContext !== null ? layoutRouterContext.parentParams : {};
}
if (typeof window === 'undefined') {
const { workAsyncStorage } = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/app-render/work-async-storage.external.js [app-client] (ecmascript)");
let clientParams;
// We are going to instrument the searchParams prop with tracking for the
// appropriate context. We wrap differently in prerendering vs rendering
const store = workAsyncStorage.getStore();
if (!store) {
throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to exist when handling params in a client segment such as a Layout or Template.'), "__NEXT_ERROR_CODE", {
value: "E600",
enumerable: false,
configurable: true
});
}
const { createParamsFromClient } = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/server/request/params.js [app-client] (ecmascript)");
clientParams = createParamsFromClient(params, store);
return /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
...slots,
params: clientParams
});
} else {
const { createRenderParamsFromClient } = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/client/request/params.browser.js [app-client] (ecmascript)");
const clientParams = createRenderParamsFromClient(params);
return /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
...slots,
params: clientParams
});
}
}
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
Object.defineProperty(exports.default, '__esModule', {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=client-segment.js.map
}),
"[project]/Documents/00 - projet/plumeia/node_modules/next/dist/lib/metadata/generate/icon-mark.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "IconMark", {
enumerable: true,
get: function() {
return IconMark;
}
});
const _jsxruntime = __turbopack_context__.r("[project]/Documents/00 - projet/plumeia/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
const IconMark = ()=>{
if (typeof window !== 'undefined') {
return null;
}
return /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
name: "\xabnxt-icon\xbb"
});
}; //# sourceMappingURL=icon-mark.js.map
}),
]);
//# sourceMappingURL=549ce_next_dist_52b68393._.js.map