2503 lines
127 KiB
JavaScript
2503 lines
127 KiB
JavaScript
(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 `<html>` element. To disable smooth scrolling during route transitions, ' + 'add `data-scroll-behavior="smooth"` to your <html> 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 <Offscreen> 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 <link/> 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 `<html/>` 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 <Activity> 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
|
|
// <userland callsite>
|
|
// 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
|