qalita 2.5.4__py3-none-any.whl → 2.6.1__py3-none-any.whl

qalita/_frontend/node_modules/next/dist/server/use-cache/use-cache-wrapper.js

@@ -14,7 +14,7 @@ const _static = require("react-server-dom-webpack/static");
 const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
 const _dynamicrenderingutils = require("../dynamic-rendering-utils");
-const _encryptionutils = require("../app-render/encryption-utils");
+const _manifestssingleton = require("../app-render/manifests-singleton");
 const _encryption = require("../app-render/encryption");
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _createerrorhandler = require("../app-render/create-error-handler");
@@ -25,8 +25,49 @@ const _dynamicrendering = require("../app-render/dynamic-rendering");
 const _searchparams = require("../request/search-params");
 const _lazyresult = require("../lib/lazy-result");
 const _dynamicaccessasyncstorageexternal = require("../app-render/dynamic-access-async-storage.external");
-const _reactlargeshellerror = require("../app-render/react-large-shell-error");
 const _stagedrendering = require("../app-render/staged-rendering");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
+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 isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge';
 const debug = process.env.NEXT_PRIVATE_DEBUG_CACHE ? console.debug.bind(console, 'use-cache:') : undefined;
 const filterStackFrame = process.env.NODE_ENV !== 'production' ? require('../lib/source-maps').filterStackFrameDEV : undefined;
@@ -279,7 +320,7 @@ async function collectResult(savedStream, workStore, cacheContext, innerCacheSto
 async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore, clientReferenceManifest, encodedArguments, fn, timeoutError) {
     const temporaryReferences = (0, _server.createTemporaryReferenceSet)();
     const outerWorkUnitStore = cacheContext.outerWorkUnitStore;
-    const [, , args] = typeof encodedArguments === 'string' ? await (0, _server.decodeReply)(encodedArguments, (0, _encryptionutils.getServerModuleMap)(), {
+    const [, , args] = typeof encodedArguments === 'string' ? await (0, _server.decodeReply)(encodedArguments, (0, _manifestssingleton.getServerModuleMap)(), {
         temporaryReferences
     }) : await (0, _server.decodeReplyFromAsyncIterable)({
         async *[Symbol.asyncIterator] () {
@@ -317,7 +358,7 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
                 }
             }
         }
-    }, (0, _encryptionutils.getServerModuleMap)(), {
+    }, (0, _manifestssingleton.getServerModuleMap)(), {
         temporaryReferences
     });
     // Track the timestamp when we started computing the result.
@@ -332,24 +373,17 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
     // digests are handled correctly. Error formatting and reporting is not
     // necessary here; the errors are encoded in the stream, and will be reported
     // in the "Server" environment.
-    const handleError = (error)=>{
-        const digest = (0, _createerrorhandler.getDigestForWellKnownError)(error);
-        if (digest) {
-            return digest;
-        }
-        if ((0, _reactlargeshellerror.isReactLargeShellError)(error)) {
-            // TODO: Aggregate
-            console.error(error);
-            return undefined;
-        }
-        if (process.env.NODE_ENV !== 'development') {
-            // TODO: For now we're also reporting the error here, because in
-            // production, the "Server" environment will only get the obfuscated
-            // error (created by the Flight Client in the cache wrapper).
-            console.error(error);
+    const handleError = (0, _createerrorhandler.createReactServerErrorHandler)(workStore.dev, workStore.isBuildTimePrerendering ?? false, workStore.reactServerErrorsByDigest, (error)=>{
+        // In production, we log the original error here. It gets a digest that
+        // can be used to associate the error with the obfuscated error that might
+        // be logged if the error is caught. In development, we prefer logging the
+        // transported error in the server environment. It's not obfuscated and
+        // also includes the (dev-only) environment name.
+        if (process.env.NODE_ENV === 'production') {
+            _log.error(error);
         }
         errors.push(error);
-    };
+    });
     let stream;
     switch(outerWorkUnitStore == null ? void 0 : outerWorkUnitStore.type){
         case 'prerender-runtime':
@@ -410,9 +444,20 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
                 stream = prelude;
             }
             break;
+        case 'request':
+            // If we're filling caches for a staged render, make sure that
+            // it takes at least a task, so we'll always notice a cache miss between stages.
+            //
+            // TODO(restart-on-cache-miss): This is suboptimal.
+            // Ideally we wouldn't need to restart for microtasky caches,
+            // but the current logic for omitting short-lived caches only works correctly
+            // if we do a second render, so that's the best we can do until we refactor that.
+            if (process.env.NODE_ENV === 'development' && outerWorkUnitStore.cacheSignal) {
+                await new Promise((resolve)=>setTimeout(resolve));
+            }
+        // fallthrough
         case 'prerender-ppr':
         case 'prerender-legacy':
-        case 'request':
         case 'cache':
         case 'private-cache':
         case 'unstable-cache':
@@ -636,7 +681,7 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
     }
     // Get the clientReferenceManifest while we're still in the outer Context.
     // In case getClientReferenceManifestSingleton is implemented using AsyncLocalStorage.
-    const clientReferenceManifest = (0, _encryptionutils.getClientReferenceManifestForRsc)();
+    const clientReferenceManifest = (0, _manifestssingleton.getClientReferenceManifest)();
     // Because the Action ID is not yet unique per implementation of that Action we can't
     // safely reuse the results across builds yet. In the meantime we add the buildId to the
     // arguments as a seed to ensure they're not reused. Remove this once Action IDs hash
@@ -1181,7 +1226,7 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
         // which themselves will handle the preloading.
         moduleLoading: null,
         moduleMap: isEdgeRuntime ? clientReferenceManifest.edgeRscModuleMapping : clientReferenceManifest.rscModuleMapping,
-        serverModuleMap: (0, _encryptionutils.getServerModuleMap)()
+        serverModuleMap: (0, _manifestssingleton.getServerModuleMap)()
     };
     return (0, _client.createFromReadableStream)(stream, {
         findSourceMapURL,

qalita/_frontend/node_modules/next/dist/server/web/edge-route-module-wrapper.js

@@ -17,15 +17,15 @@ const _serverutils = require("../server-utils");
 const _querystring = require("../../shared/lib/router/utils/querystring");
 const _webonclose = require("./web-on-close");
 const _getedgepreviewprops = require("./get-edge-preview-props");
+const _web = require("../../server/base-http/web");
 class EdgeRouteModuleWrapper {
     /**
    * The constructor is wrapped with private to ensure that it can only be
    * constructed by the static wrap method.
    *
    * @param routeModule the route module to wrap
-   */ constructor(routeModule, nextConfig){
+   */ constructor(routeModule){
         this.routeModule = routeModule;
-        this.nextConfig = nextConfig;
         // TODO: (wyattjoh) possibly allow the module to define it's own matcher
         this.matcher = new _routematcher.RouteMatcher(routeModule.definition);
     }
@@ -39,14 +39,15 @@ class EdgeRouteModuleWrapper {
    * @returns a function that can be used as a handler for the edge runtime
    */ static wrap(routeModule, options) {
         // Create the module wrapper.
-        const wrapper = new EdgeRouteModuleWrapper(routeModule, options.nextConfig);
+        const wrapper = new EdgeRouteModuleWrapper(routeModule);
         // Return the wrapping function.
         return (opts)=>{
             return (0, _adapter.adapter)({
                 ...opts,
                 IncrementalCache: _incrementalcache.IncrementalCache,
                 // Bind the handler method to the wrapper so it still has context.
-                handler: wrapper.handler.bind(wrapper)
+                handler: wrapper.handler.bind(wrapper),
+                page: options.page
             });
         };
     }
@@ -60,6 +61,7 @@ class EdgeRouteModuleWrapper {
             // only used for rewrites, so setting an arbitrary default value here
             caseSensitive: false
         });
+        const { nextConfig } = this.routeModule.getNextConfigEdge(new _web.WebNextRequest(request));
         const { params } = utils.normalizeDynamicRouteParams((0, _querystring.searchParamsToUrlQuery)(request.nextUrl.searchParams), false);
         const waitUntil = evt.waitUntil.bind(evt);
         const closeController = new _webonclose.CloseController();
@@ -84,7 +86,7 @@ class EdgeRouteModuleWrapper {
                 experimental: {
                     authInterrupts: !!process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS
                 },
-                cacheLifeProfiles: this.nextConfig.cacheLife
+                cacheLifeProfiles: nextConfig.cacheLife
             },
             sharedContext: {
                 buildId: ''

qalita/_frontend/node_modules/next/dist/server/web/sandbox/context.js

@@ -99,15 +99,14 @@ async function loadWasm(wasm) {
     return modules;
 }
 function buildEnvironmentVariablesFrom(injectedEnvironments) {
-    const pairs = Object.keys(process.env).map((key)=>[
-            key,
-            process.env[key]
-        ]);
-    const env = Object.fromEntries(pairs);
-    for (const key of Object.keys(injectedEnvironments)){
-        env[key] = injectedEnvironments[key];
-    }
-    env.NEXT_RUNTIME = 'edge';
+    let env = Object.fromEntries([
+        ...Object.entries(process.env),
+        ...Object.entries(injectedEnvironments),
+        [
+            'NEXT_RUNTIME',
+            'edge'
+        ]
+    ]);
     return env;
 }
 function throwUnsupportedAPIError(name) {

qalita/_frontend/node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.js

@@ -47,6 +47,7 @@ _export(exports, {
 const _cookies = require("../cookies");
 const _reflect = require("./reflect");
 const _workasyncstorageexternal = require("../../../app-render/work-async-storage.external");
+const _actionrevalidationkind = require("../../../../shared/lib/action-revalidation-kind");
 class ReadonlyRequestCookiesError extends Error {
     constructor(){
         super('Cookies can only be modified in a Server Action or Route Handler. Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options');
@@ -111,7 +112,7 @@ class MutableRequestCookiesAdapter {
             // TODO-APP: change method of getting workStore
             const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
             if (workStore) {
-                workStore.pathWasRevalidated = true;
+                workStore.pathWasRevalidated = _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic;
             }
             const allCookies = responseCookies.getAll();
             modifiedValues = allCookies.filter((c)=>modifiedCookies.has(c.name));

qalita/_frontend/node_modules/next/dist/server/web/spec-extension/revalidate.js

@@ -35,6 +35,7 @@ const _workasyncstorageexternal = require("../../app-render/work-async-storage.e
 const _workunitasyncstorageexternal = require("../../app-render/work-unit-async-storage.external");
 const _hooksservercontext = require("../../../client/components/hooks-server-context");
 const _invarianterror = require("../../../shared/lib/invariant-error");
+const _actionrevalidationkind = require("../../../shared/lib/action-revalidation-kind");
 function revalidateTag(tag, profile) {
     if (!profile) {
         console.warn('"revalidateTag" without the second argument is now deprecated, add second argument of "max" or use "updateTag". See more info here: https://nextjs.org/docs/messages/revalidate-tag-single-arg');
@@ -70,8 +71,9 @@ function refresh() {
         });
     }
     if (workStore) {
-        // TODO: break this to it's own field
-        workStore.pathWasRevalidated = true;
+        // The Server Action version of refresh() only revalidates the dynamic data
+        // on the client. It doesn't affect cached data.
+        workStore.pathWasRevalidated = _actionrevalidationkind.ActionDidRevalidateDynamicOnly;
     }
 }
 function revalidatePath(originalPath, type) {
@@ -161,6 +163,8 @@ function revalidate(tags, expression, profile) {
                     // status being flipped when revalidating a static page with a server
                     // action.
                     workUnitStore.usedDynamic = true;
+                // TODO(restart-on-cache-miss): we should do a sync IO error here in dev
+                // to match prerender behavior
                 }
                 break;
             default:
@@ -195,7 +199,7 @@ function revalidate(tags, expression, profile) {
     const cacheLife = profile && typeof profile === 'object' ? profile : profile && typeof profile === 'string' && (store == null ? void 0 : (_store_cacheLifeProfiles = store.cacheLifeProfiles) == null ? void 0 : _store_cacheLifeProfiles[profile]) ? store.cacheLifeProfiles[profile] : undefined;
     if (!profile || (cacheLife == null ? void 0 : cacheLife.expire) === 0) {
         // TODO: only revalidate if the path matches
-        store.pathWasRevalidated = true;
+        store.pathWasRevalidated = _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic;
     }
 }
 

qalita/_frontend/node_modules/next/dist/shared/lib/action-revalidation-kind.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ActionDidNotRevalidate: null,
+    ActionDidRevalidateDynamicOnly: null,
+    ActionDidRevalidateStaticAndDynamic: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ActionDidNotRevalidate: function() {
+        return ActionDidNotRevalidate;
+    },
+    ActionDidRevalidateDynamicOnly: function() {
+        return ActionDidRevalidateDynamicOnly;
+    },
+    ActionDidRevalidateStaticAndDynamic: function() {
+        return ActionDidRevalidateStaticAndDynamic;
+    }
+});
+const ActionDidNotRevalidate = 0;
+const ActionDidRevalidateStaticAndDynamic = 1;
+const ActionDidRevalidateDynamicOnly = 2;
+
+//# sourceMappingURL=action-revalidation-kind.js.map

qalita/_frontend/node_modules/next/dist/shared/lib/constants.js

@@ -43,6 +43,7 @@ Object.defineProperty(exports, "__esModule", {
     NEXT_BUILTIN_DOCUMENT: null,
     NEXT_FONT_MANIFEST: null,
     PAGES_MANIFEST: null,
+    PHASE_ANALYZE: null,
     PHASE_DEVELOPMENT_SERVER: null,
     PHASE_EXPORT: null,
     PHASE_INFO: null,
@@ -199,6 +200,9 @@ _export(exports, {
     PAGES_MANIFEST: function() {
         return PAGES_MANIFEST;
     },
+    PHASE_ANALYZE: function() {
+        return PHASE_ANALYZE;
+    },
     PHASE_DEVELOPMENT_SERVER: function() {
         return PHASE_DEVELOPMENT_SERVER;
     },
@@ -325,6 +329,7 @@ var AdapterOutputType = /*#__PURE__*/ function(AdapterOutputType) {
     return AdapterOutputType;
 }({});
 const PHASE_EXPORT = 'phase-export';
+const PHASE_ANALYZE = 'phase-analyze';
 const PHASE_PRODUCTION_BUILD = 'phase-production-build';
 const PHASE_PRODUCTION_SERVER = 'phase-production-server';
 const PHASE_DEVELOPMENT_SERVER = 'phase-development-server';
@@ -343,7 +348,7 @@ const EXPORT_DETAIL = 'export-detail.json';
 const PRERENDER_MANIFEST = 'prerender-manifest.json';
 const ROUTES_MANIFEST = 'routes-manifest.json';
 const IMAGES_MANIFEST = 'images-manifest.json';
-const SERVER_FILES_MANIFEST = 'required-server-files.json';
+const SERVER_FILES_MANIFEST = 'required-server-files';
 const DEV_CLIENT_PAGES_MANIFEST = '_devPagesManifest.json';
 const MIDDLEWARE_MANIFEST = 'middleware-manifest.json';
 const TURBOPACK_CLIENT_MIDDLEWARE_MANIFEST = '_clientMiddlewareManifest.json';

qalita/_frontend/node_modules/next/dist/shared/lib/deployment-id.js

@@ -0,0 +1,36 @@
+// This could also be a variable instead of a function, but some unit tests want to change the ID at
+// runtime. Even though that would never happen in a real deployment.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getDeploymentId: null,
+    getDeploymentIdQueryOrEmptyString: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getDeploymentId: function() {
+        return getDeploymentId;
+    },
+    getDeploymentIdQueryOrEmptyString: function() {
+        return getDeploymentIdQueryOrEmptyString;
+    }
+});
+function getDeploymentId() {
+    return process.env.NEXT_DEPLOYMENT_ID;
+}
+function getDeploymentIdQueryOrEmptyString() {
+    let deploymentId = getDeploymentId();
+    if (deploymentId) {
+        return `?dpl=${deploymentId}`;
+    }
+    return '';
+}
+
+//# sourceMappingURL=deployment-id.js.map

qalita/_frontend/node_modules/next/dist/shared/lib/errors/canary-only-config-error.js

@@ -21,7 +21,7 @@ _export(exports, {
     }
 });
 function isStableBuild() {
-    return !"16.0.10"?.includes('canary') && !process.env.__NEXT_TEST_MODE && !process.env.NEXT_PRIVATE_LOCAL_DEV;
+    return !"16.1.1"?.includes('canary') && !process.env.__NEXT_TEST_MODE && !process.env.NEXT_PRIVATE_LOCAL_DEV;
 }
 class CanaryOnlyConfigError extends Error {
     constructor(arg){

qalita/_frontend/node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", {
     NavigationPromisesContext: null,
     PathParamsContext: null,
     PathnameContext: null,
+    ReadonlyURLSearchParams: null,
     SearchParamsContext: null,
     createDevToolsInstrumentedPromise: null
 });
@@ -26,6 +27,9 @@ _export(exports, {
     PathnameContext: function() {
         return PathnameContext;
     },
+    ReadonlyURLSearchParams: function() {
+        return _readonlyurlsearchparams.ReadonlyURLSearchParams;
+    },
     SearchParamsContext: function() {
         return SearchParamsContext;
     },
@@ -34,6 +38,7 @@ _export(exports, {
     }
 });
 const _react = require("react");
+const _readonlyurlsearchparams = require("../../client/components/readonly-url-search-params");
 const SearchParamsContext = (0, _react.createContext)(null);
 const PathnameContext = (0, _react.createContext)(null);
 const PathParamsContext = (0, _react.createContext)(null);

qalita/_frontend/node_modules/next/dist/shared/lib/router/routes/app.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    isInterceptionAppRoute: null,
+    isNormalizedAppRoute: null,
+    parseAppRoute: null,
+    parseAppRouteSegment: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isInterceptionAppRoute: function() {
+        return isInterceptionAppRoute;
+    },
+    isNormalizedAppRoute: function() {
+        return isNormalizedAppRoute;
+    },
+    parseAppRoute: function() {
+        return parseAppRoute;
+    },
+    parseAppRouteSegment: function() {
+        return parseAppRouteSegment;
+    }
+});
+const _invarianterror = require("../../invariant-error");
+const _getsegmentparam = require("../utils/get-segment-param");
+const _interceptionroutes = require("../utils/interception-routes");
+function parseAppRouteSegment(segment) {
+    if (segment === '') {
+        return null;
+    }
+    // Check if the segment starts with an interception marker
+    const interceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m));
+    const param = (0, _getsegmentparam.getSegmentParam)(segment);
+    if (param) {
+        return {
+            type: 'dynamic',
+            name: segment,
+            param,
+            interceptionMarker
+        };
+    } else if (segment.startsWith('(') && segment.endsWith(')')) {
+        return {
+            type: 'route-group',
+            name: segment,
+            interceptionMarker
+        };
+    } else if (segment.startsWith('@')) {
+        return {
+            type: 'parallel-route',
+            name: segment,
+            interceptionMarker
+        };
+    } else {
+        return {
+            type: 'static',
+            name: segment,
+            interceptionMarker
+        };
+    }
+}
+function isNormalizedAppRoute(route) {
+    return route.normalized;
+}
+function isInterceptionAppRoute(route) {
+    return route.interceptionMarker !== undefined && route.interceptingRoute !== undefined && route.interceptedRoute !== undefined;
+}
+function parseAppRoute(pathname, normalized) {
+    const pathnameSegments = pathname.split('/').filter(Boolean);
+    // Build segments array with static and dynamic segments
+    const segments = [];
+    // Parse if this is an interception route.
+    let interceptionMarker;
+    let interceptingRoute;
+    let interceptedRoute;
+    for (const segment of pathnameSegments){
+        // Parse the segment into an AppSegment.
+        const appSegment = parseAppRouteSegment(segment);
+        if (!appSegment) {
+            continue;
+        }
+        if (normalized && (appSegment.type === 'route-group' || appSegment.type === 'parallel-route')) {
+            throw Object.defineProperty(new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a route group or parallel route segment.`), "__NEXT_ERROR_CODE", {
+                value: "E923",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        segments.push(appSegment);
+        if (appSegment.interceptionMarker) {
+            const parts = pathname.split(appSegment.interceptionMarker);
+            if (parts.length !== 2) {
+                throw Object.defineProperty(new Error(`Invalid interception route: ${pathname}`), "__NEXT_ERROR_CODE", {
+                    value: "E924",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            interceptingRoute = normalized ? parseAppRoute(parts[0], true) : parseAppRoute(parts[0], false);
+            interceptedRoute = normalized ? parseAppRoute(parts[1], true) : parseAppRoute(parts[1], false);
+            interceptionMarker = appSegment.interceptionMarker;
+        }
+    }
+    const dynamicSegments = segments.filter((segment)=>segment.type === 'dynamic');
+    return {
+        normalized,
+        pathname,
+        segments,
+        dynamicSegments,
+        interceptionMarker,
+        interceptingRoute,
+        interceptedRoute
+    };
+}
+
+//# sourceMappingURL=app.js.map

qalita/_frontend/node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.js

@@ -34,7 +34,8 @@ _export(exports, {
 });
 const _invarianterror = require("../../invariant-error");
 const _parseloadertree = require("./parse-loader-tree");
-const _getsegmentparam = require("./get-segment-param");
+const _app = require("../routes/app");
+const _resolveparamvalue = require("./resolve-param-value");
 /**
  * Gets the value of a param from the params object. This correctly handles the
  * case where the param is a fallback route param and encodes the resulting
@@ -67,66 +68,36 @@ function interpolateParallelRouteParams(loaderTree, params, pagePath, fallbackRo
             depth: 0
         }
     ];
-    // Derive value from pagePath based on depth and parameter type
-    const pathSegments = pagePath.split('/').slice(1) // Remove first empty string
-    ;
+    // Parse the route from the provided page path.
+    const route = (0, _app.parseAppRoute)(pagePath, true);
     while(stack.length > 0){
         const { tree, depth } = stack.pop();
         const { segment, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
-        // Check if current segment contains a parameter
-        const segmentParam = (0, _getsegmentparam.getSegmentParam)(segment);
-        if (segmentParam && !interpolated.hasOwnProperty(segmentParam.param) && // If the param is in the fallback route params, we don't need to
+        const appSegment = (0, _app.parseAppRouteSegment)(segment);
+        if (appSegment?.type === 'dynamic' && !interpolated.hasOwnProperty(appSegment.param.paramName) && // If the param is in the fallback route params, we don't need to
         // interpolate it because it's already marked as being unknown.
-        !fallbackRouteParams?.has(segmentParam.param)) {
-            switch(segmentParam.type){
-                case 'catchall':
-                case 'optional-catchall':
-                case 'catchall-intercepted-(..)(..)':
-                case 'catchall-intercepted-(.)':
-                case 'catchall-intercepted-(..)':
-                case 'catchall-intercepted-(...)':
-                    // For catchall parameters, take all remaining segments from this depth
-                    const remainingSegments = pathSegments.slice(depth);
-                    // Process each segment to handle any dynamic params
-                    const processedSegments = remainingSegments.flatMap((pathSegment)=>{
-                        const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
-                        // If the segment matches a param, return the param value otherwise,
-                        // it's a static segment, so just return that. We don't use the
-                        // `getParamValue` function here because we don't want the values to
-                        // be encoded, that's handled on get by the `getDynamicParam`
-                        // function.
-                        return param ? interpolated[param.param] : pathSegment;
-                    }).filter((s)=>s !== undefined);
-                    if (processedSegments.length > 0) {
-                        interpolated[segmentParam.param] = processedSegments;
-                    }
-                    break;
-                case 'dynamic':
-                case 'dynamic-intercepted-(..)(..)':
-                case 'dynamic-intercepted-(.)':
-                case 'dynamic-intercepted-(..)':
-                case 'dynamic-intercepted-(...)':
-                    // For regular dynamic parameters, take the segment at this depth
-                    if (depth < pathSegments.length) {
-                        const pathSegment = pathSegments[depth];
-                        const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
-                        interpolated[segmentParam.param] = param ? interpolated[param.param] : pathSegment;
-                    }
-                    break;
-                default:
-                    segmentParam.type;
+        !fallbackRouteParams?.has(appSegment.param.paramName)) {
+            const { paramName, paramType } = appSegment.param;
+            const paramValue = (0, _resolveparamvalue.resolveParamValue)(paramName, paramType, depth, route, interpolated);
+            if (paramValue !== undefined) {
+                interpolated[paramName] = paramValue;
+            } else if (paramType !== 'optional-catchall') {
+                throw Object.defineProperty(new _invarianterror.InvariantError(`Could not resolve param value for segment: ${paramName}`), "__NEXT_ERROR_CODE", {
+                    value: "E932",
+                    enumerable: false,
+                    configurable: true
+                });
             }
         }
         // Calculate next depth - increment if this is not a route group and not empty
         let nextDepth = depth;
-        const isRouteGroup = segment.startsWith('(') && segment.endsWith(')');
-        if (!isRouteGroup && segment !== '') {
+        if (appSegment && appSegment.type !== 'route-group' && appSegment.type !== 'parallel-route') {
             nextDepth++;
         }
         // Add all parallel routes to the stack for processing
-        for (const route of Object.values(parallelRoutes)){
+        for (const parallelRoute of Object.values(parallelRoutes)){
             stack.push({
-                tree: route,
+                tree: parallelRoute,
                 depth: nextDepth
             });
         }