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

qalita/_frontend/node_modules/next/dist/build/static-paths/app.js

@@ -8,8 +8,7 @@ Object.defineProperty(exports, "__esModule", {
     calculateFallbackMode: null,
     filterUniqueParams: null,
     generateAllParamCombinations: null,
-    generateRouteStaticParams: null,
-    resolveParallelRouteParams: null
+    generateRouteStaticParams: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -35,9 +34,6 @@ _export(exports, {
     },
     generateRouteStaticParams: function() {
         return generateRouteStaticParams;
-    },
-    resolveParallelRouteParams: function() {
-        return resolveParallelRouteParams;
     }
 });
 const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
@@ -47,11 +43,9 @@ const _fallback = require("../../lib/fallback");
 const _utils = require("./utils");
 const _escapepathdelimiters = /*#__PURE__*/ _interop_require_default(require("../../shared/lib/router/utils/escape-path-delimiters"));
 const _createincrementalcache = require("../../export/helpers/create-incremental-cache");
-const _invarianterror = require("../../shared/lib/invariant-error");
 const _getsegmentparam = require("../../shared/lib/router/utils/get-segment-param");
-const _parseloadertree = require("../../shared/lib/router/utils/parse-loader-tree");
-const _interceptionroutes = require("../../shared/lib/router/utils/interception-routes");
 const _emptygeneratestaticparamserror = require("../../shared/lib/errors/empty-generate-static-params-error");
+const _interceptionprefixfromparamtype = require("../../shared/lib/router/utils/interception-prefix-from-param-type");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -222,11 +216,11 @@ function calculateFallbackMode(dynamicParams, fallbackRootParams, baseFallbackMo
  * @param page - The page to validate.
  * @param regex - The route regex.
  * @param isRoutePPREnabled - Whether the route has partial prerendering enabled.
- * @param childrenRouteParamSegments - The keys of the parameters.
+ * @param pathnameSegments - The keys of the parameters.
  * @param rootParamKeys - The keys of the root params.
  * @param routeParams - The list of parameters to validate.
  * @returns The list of validated parameters.
- */ function validateParams(page, isRoutePPREnabled, childrenRouteParamSegments, rootParamKeys, routeParams) {
+ */ function validateParams(page, isRoutePPREnabled, pathnameSegments, rootParamKeys, routeParams) {
     const valid = [];
     // Validate that if there are any root params, that the user has provided at
     // least one value for them only if we're using partial prerendering.
@@ -248,7 +242,7 @@ function calculateFallbackMode(dynamicParams, fallbackRootParams, baseFallbackMo
     }
     for (const params of routeParams){
         const item = {};
-        for (const { paramName: key, paramType } of childrenRouteParamSegments){
+        for (const { paramName: key, paramType } of pathnameSegments){
             const { repeat, optional } = (0, _getsegmentparam.getParamProperties)(paramType);
             let paramValue = params[key];
             if (optional && params.hasOwnProperty(key) && (paramValue === null || paramValue === undefined || paramValue === false)) {
@@ -286,7 +280,7 @@ function calculateFallbackMode(dynamicParams, fallbackRootParams, baseFallbackMo
     }
     return valid;
 }
-function assignErrorIfEmpty(prerenderedRoutes, childrenRouteParams) {
+function assignErrorIfEmpty(prerenderedRoutes, pathnameSegments) {
     // If there are no routes to process, exit early.
     if (prerenderedRoutes.length === 0) {
         return;
@@ -307,7 +301,7 @@ function assignErrorIfEmpty(prerenderedRoutes, childrenRouteParams) {
         // for ensuring that routes with the same concrete parameters follow the
         // same path in the Trie, regardless of the original order of properties
         // in the `params` object.
-        for (const { paramName: key } of childrenRouteParams){
+        for (const { paramName: key } of pathnameSegments){
             // Check if the current route actually has a concrete value for this parameter.
             // If a dynamic segment is not filled (i.e., it's a fallback), it won't have
             // this property, and we stop building the path for this route at this point.
@@ -406,129 +400,6 @@ function assignErrorIfEmpty(prerenderedRoutes, childrenRouteParams) {
         }
     }
 }
-function resolveParallelRouteParams(loaderTree, params, pathname, fallbackRouteParams) {
-    // Stack-based traversal with depth and parallel route key tracking
-    const stack = [
-        {
-            tree: loaderTree,
-            depth: 0,
-            parallelKey: 'children'
-        }
-    ];
-    // Parse pathname into segments for depth-based resolution
-    const pathSegments = pathname.split('/').filter(Boolean);
-    while(stack.length > 0){
-        const { tree, depth, parallelKey } = stack.pop();
-        const { segment, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
-        // Only process segments that are in parallel routes (not the main 'children' route)
-        if (parallelKey !== 'children') {
-            const segmentParam = (0, _getsegmentparam.getSegmentParam)(segment);
-            if (segmentParam && !params.hasOwnProperty(segmentParam.param)) {
-                const { param: paramName, type: paramType } = segmentParam;
-                switch(paramType){
-                    case 'catchall':
-                    case 'optional-catchall':
-                    case 'catchall-intercepted-(..)(..)':
-                    case 'catchall-intercepted-(.)':
-                    case 'catchall-intercepted-(..)':
-                    case 'catchall-intercepted-(...)':
-                        // If there are any non-parallel fallback route segments, we can't use the
-                        // pathname to derive the value because it's not complete. We can make
-                        // this assumption because routes are resolved left to right.
-                        if (fallbackRouteParams.some((param)=>!param.isParallelRouteParam)) {
-                            fallbackRouteParams.push((0, _utils.createFallbackRouteParam)(paramName, paramType, true));
-                            break;
-                        }
-                        // For catchall routes in parallel segments, derive from pathname
-                        // using depth to determine which segments to use
-                        const remainingSegments = pathSegments.slice(depth);
-                        // Process segments to handle any embedded dynamic params
-                        // Track if we encounter any unknown param placeholders
-                        let hasUnknownParam = false;
-                        const processedSegments = remainingSegments.flatMap((pathSegment)=>{
-                            const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
-                            if (param) {
-                                // If the segment is a param placeholder, check if we have its value
-                                if (!params.hasOwnProperty(param.param)) {
-                                    // Unknown param placeholder in pathname - can't derive full value
-                                    hasUnknownParam = true;
-                                    return undefined;
-                                }
-                                // If the segment matches a param, return the param value
-                                // We don't encode values here as that's handled during retrieval.
-                                return params[param.param];
-                            }
-                            // Otherwise it's a static segment
-                            return pathSegment;
-                        }).filter((s)=>s !== undefined);
-                        // If we encountered any unknown param placeholders, we can't derive
-                        // the full catch-all value from the pathname, so mark as fallback.
-                        if (hasUnknownParam) {
-                            fallbackRouteParams.push((0, _utils.createFallbackRouteParam)(paramName, paramType, true));
-                            break;
-                        }
-                        if (processedSegments.length > 0) {
-                            params[paramName] = processedSegments;
-                        } else if (paramType === 'optional-catchall') {
-                            params[paramName] = [];
-                        } else {
-                            // We shouldn't be able to match a catchall segment without any path
-                            // segments if it's not an optional catchall
-                            throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected empty path segments match for a pathname "${pathname}" with param "${paramName}" of type "${paramType}"`), "__NEXT_ERROR_CODE", {
-                                value: "E792",
-                                enumerable: false,
-                                configurable: true
-                            });
-                        }
-                        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);
-                            // Check if the segment at this depth is a placeholder for an unknown param
-                            if (param && !params.hasOwnProperty(param.param)) {
-                                // The segment is a placeholder like [category] and we don't have the value
-                                fallbackRouteParams.push((0, _utils.createFallbackRouteParam)(paramName, paramType, true));
-                                break;
-                            }
-                            // If the segment matches a param, use the param value from params object
-                            // Otherwise it's a static segment, just use it directly
-                            // We don't encode values here as that's handled during retrieval
-                            params[paramName] = param ? params[param.param] : pathSegment;
-                        } else {
-                            // No segment at this depth, mark as fallback.
-                            fallbackRouteParams.push((0, _utils.createFallbackRouteParam)(paramName, paramType, true));
-                        }
-                        break;
-                    default:
-                        paramType;
-                }
-            }
-        }
-        // Calculate next depth - increment if this is not a route group and not empty
-        let nextDepth = depth;
-        // Route groups are like (marketing) or (dashboard), NOT interception routes like (.)photo
-        // Interception routes start with markers like (.), (..), (...), (..)(..)) and should increment depth
-        const isInterceptionRoute = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((marker)=>segment.startsWith(marker));
-        const isRouteGroup = !isInterceptionRoute && segment.startsWith('(') && segment.endsWith(')');
-        if (!isRouteGroup && segment !== '') {
-            nextDepth++;
-        }
-        // Add all parallel routes to the stack for processing.
-        for (const [key, route] of Object.entries(parallelRoutes)){
-            stack.push({
-                tree: route,
-                depth: nextDepth,
-                parallelKey: key
-            });
-        }
-    }
-}
 async function generateRouteStaticParams(segments, store, isRoutePPREnabled) {
     // Early return if no segments to process
     if (segments.length === 0) return [];
@@ -601,7 +472,23 @@ async function generateRouteStaticParams(segments, store, isRoutePPREnabled) {
     }
     return currentParams;
 }
-async function buildAppStaticPaths({ dir, page, distDir, cacheComponents, authInterrupts, segments, isrFlushToDisk, cacheHandler, cacheLifeProfiles, requestHeaders, cacheHandlers, cacheMaxMemorySize, fetchCacheKeyPrefix, nextConfigOutput, ComponentMod, isRoutePPREnabled = false, buildId, rootParamKeys }) {
+function createReplacements(segment, paramValue) {
+    // Determine the prefix to use for the interception marker.
+    let prefix;
+    if (segment.paramType) {
+        prefix = (0, _interceptionprefixfromparamtype.interceptionPrefixFromParamType)(segment.paramType) ?? '';
+    } else {
+        prefix = '';
+    }
+    return {
+        pathname: prefix + (0, _utils.encodeParam)(paramValue, (value)=>// Only escape path delimiters if the value is a string, the following
+            // version will URL encode the value.
+            (0, _escapepathdelimiters.default)(value, true)),
+        encodedPathname: prefix + (0, _utils.encodeParam)(paramValue, // URL encode the value.
+        encodeURIComponent)
+    };
+}
+async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents, authInterrupts, segments, isrFlushToDisk, cacheHandler, cacheLifeProfiles, requestHeaders, cacheHandlers, cacheMaxMemorySize, fetchCacheKeyPrefix, nextConfigOutput, ComponentMod, isRoutePPREnabled = false, buildId, rootParamKeys }) {
     if (segments.some((generate)=>{
         var _generate_config;
         return ((_generate_config = generate.config) == null ? void 0 : _generate_config.dynamicParams) === true;
@@ -623,44 +510,11 @@ async function buildAppStaticPaths({ dir, page, distDir, cacheComponents, authIn
         flushToDisk: isrFlushToDisk,
         cacheMaxMemorySize
     });
-    const childrenRouteParamSegments = [];
-    // These are all the parallel fallback route params that will be included when
-    // we're emitting the route for the base route.
-    const parallelFallbackRouteParams = [];
-    // First pass: collect all non-parallel route param names.
-    // This allows us to filter out parallel route params that duplicate non-parallel ones.
-    const nonParallelParamNames = new Set();
-    for (const segment of segments){
-        if (!segment.paramName || !segment.paramType) continue;
-        if (!segment.isParallelRouteSegment) {
-            nonParallelParamNames.add(segment.paramName);
-        }
-    }
-    // Second pass: collect segments, ensuring non-parallel route params take precedence.
-    for (const segment of segments){
-        // If this segment doesn't have a param name then it's not param that we
-        // need to resolve.
-        if (!segment.paramName || !segment.paramType) continue;
-        if (segment.isParallelRouteSegment) {
-            // Skip parallel route params that are already defined as non-parallel route params.
-            // Non-parallel route params take precedence because they appear in the URL pathname.
-            if (nonParallelParamNames.has(segment.paramName)) {
-                continue;
-            }
-            // Collect parallel fallback route params for the base route.
-            // The actual parallel route param resolution is now handled by
-            // resolveParallelRouteParams using the loader tree.
-            parallelFallbackRouteParams.push((0, _utils.createFallbackRouteParam)(segment.paramName, segment.paramType, true));
-        } else {
-            // Collect all the route param keys that are not parallel route params.
-            // These are the ones that will be included in the request pathname.
-            childrenRouteParamSegments.push({
-                name: segment.name,
-                paramName: segment.paramName,
-                paramType: segment.paramType
-            });
-        }
-    }
+    // Extract segments that contribute to the pathname.
+    // For AppPageRouteModule: Traverses the loader tree to find all segments (including
+    //   interception routes in parallel slots) that match the pathname
+    // For AppRouteRouteModule: Filters the segments array to get non-parallel route params
+    const pathnameRouteParamSegments = (0, _utils.extractPathnameRouteParamSegments)(ComponentMod.routeModule, segments, route);
     const afterRunner = new _runwithafter.AfterRunner();
     const store = (0, _workstore.createWorkStore)({
         page,
@@ -686,7 +540,7 @@ async function buildAppStaticPaths({ dir, page, distDir, cacheComponents, authIn
         var _segment_config;
         // Check to see if there are any missing params for segments that have
         // dynamicParams set to false.
-        if (segment.paramName && segment.isDynamicSegment && ((_segment_config = segment.config) == null ? void 0 : _segment_config.dynamicParams) === false) {
+        if (segment.paramName && segment.paramType && ((_segment_config = segment.config) == null ? void 0 : _segment_config.dynamicParams) === false) {
             for (const params of routeParams){
                 if (segment.paramName in params) continue;
                 const relative = segment.filePath ? _nodepath.default.relative(dir, segment.filePath) : undefined;
@@ -697,15 +551,15 @@ async function buildAppStaticPaths({ dir, page, distDir, cacheComponents, authIn
                 });
             }
         }
-        if (segment.isDynamicSegment && typeof segment.generateStaticParams !== 'function') {
+        if (segment.paramName && segment.paramType && typeof segment.generateStaticParams !== 'function') {
             lastDynamicSegmentHadGenerateStaticParams = false;
         } else if (typeof segment.generateStaticParams === 'function') {
             lastDynamicSegmentHadGenerateStaticParams = true;
         }
     }
     // Determine if all the segments have had their parameters provided.
-    const hadAllParamsGenerated = childrenRouteParamSegments.length === 0 || routeParams.length > 0 && routeParams.every((params)=>{
-        for (const { paramName } of childrenRouteParamSegments){
+    const hadAllParamsGenerated = pathnameRouteParamSegments.length === 0 || routeParams.length > 0 && routeParams.every((params)=>{
+        for (const { paramName } of pathnameRouteParamSegments){
             if (paramName in params) continue;
             return false;
         }
@@ -729,13 +583,16 @@ async function buildAppStaticPaths({ dir, page, distDir, cacheComponents, authIn
             // Discover all unique combinations of the routeParams so we can generate
             // routes that won't throw on empty static shell for each of them if
             // they're available.
-            paramsToProcess = generateAllParamCombinations(childrenRouteParamSegments, routeParams, rootParamKeys);
-            // The fallback route params for this route is a combination of the
-            // parallel route params and the non-parallel route params.
-            const fallbackRouteParams = [
-                ...childrenRouteParamSegments.map(({ paramName, paramType: type })=>(0, _utils.createFallbackRouteParam)(paramName, type, false)),
-                ...parallelFallbackRouteParams
-            ];
+            paramsToProcess = generateAllParamCombinations(pathnameRouteParamSegments, routeParams, rootParamKeys);
+            // Collect all the fallback route params for the segments.
+            const fallbackRouteParams = [];
+            for (const segment of segments){
+                if (!segment.paramName || !segment.paramType) continue;
+                fallbackRouteParams.push({
+                    paramName: segment.paramName,
+                    paramType: segment.paramType
+                });
+            }
             // Add the base route, this is the route with all the placeholders as it's
             // derived from the `page` string.
             prerenderedRoutesByPathname.set(page, {
@@ -748,18 +605,24 @@ async function buildAppStaticPaths({ dir, page, distDir, cacheComponents, authIn
                 throwOnEmptyStaticShell: true
             });
         }
-        filterUniqueParams(childrenRouteParamSegments, validateParams(page, isRoutePPREnabled, childrenRouteParamSegments, rootParamKeys, paramsToProcess)).forEach((params)=>{
+        filterUniqueParams(pathnameRouteParamSegments, validateParams(page, isRoutePPREnabled, pathnameRouteParamSegments, rootParamKeys, paramsToProcess)).forEach((params)=>{
             let pathname = page;
             let encodedPathname = page;
             const fallbackRouteParams = [];
-            for (const { paramName: key, paramType: type } of childrenRouteParamSegments){
-                const paramValue = params[key];
+            for (const { name, paramName, paramType } of pathnameRouteParamSegments){
+                const paramValue = params[paramName];
                 if (!paramValue) {
                     if (isRoutePPREnabled) {
                         // Mark remaining params as fallback params.
-                        fallbackRouteParams.push((0, _utils.createFallbackRouteParam)(key, type, false));
-                        for(let i = childrenRouteParamSegments.findIndex((param)=>param.paramName === key) + 1; i < childrenRouteParamSegments.length; i++){
-                            fallbackRouteParams.push((0, _utils.createFallbackRouteParam)(childrenRouteParamSegments[i].paramName, childrenRouteParamSegments[i].paramType, false));
+                        fallbackRouteParams.push({
+                            paramName,
+                            paramType
+                        });
+                        for(let i = pathnameRouteParamSegments.findIndex((param)=>param.paramName === paramName) + 1; i < pathnameRouteParamSegments.length; i++){
+                            fallbackRouteParams.push({
+                                paramName: pathnameRouteParamSegments[i].paramName,
+                                paramType: pathnameRouteParamSegments[i].paramType
+                            });
                         }
                         break;
                     } else {
@@ -768,27 +631,23 @@ async function buildAppStaticPaths({ dir, page, distDir, cacheComponents, authIn
                         return;
                     }
                 }
-                const segment = childrenRouteParamSegments.find(({ paramName })=>paramName === key);
-                if (!segment) {
-                    throw Object.defineProperty(new _invarianterror.InvariantError(`Param ${key} not found in childrenRouteParamSegments ${childrenRouteParamSegments.map(({ paramName })=>paramName).join(', ')}`), "__NEXT_ERROR_CODE", {
-                        value: "E894",
-                        enumerable: false,
-                        configurable: true
-                    });
-                }
-                pathname = pathname.replace(segment.name, (0, _utils.encodeParam)(paramValue, (value)=>(0, _escapepathdelimiters.default)(value, true)));
-                encodedPathname = encodedPathname.replace(segment.name, (0, _utils.encodeParam)(paramValue, encodeURIComponent));
+                const replacements = createReplacements({
+                    paramType
+                }, paramValue);
+                pathname = pathname.replace(name, // We're replacing the segment name with the replacement pathname
+                // which will include the interception marker prefix if it exists.
+                replacements.pathname);
+                encodedPathname = encodedPathname.replace(name, // We're replacing the segment name with the replacement encoded
+                // pathname which will include the encoded param value.
+                replacements.encodedPathname);
             }
-            // Resolve parallel route params from the loader tree if this is from an
-            // app page.
+            // Resolve all route params from the loader tree if this is from an
+            // app page. This processes both regular route params and parallel route params.
             if ('loaderTree' in ComponentMod.routeModule.userland && Array.isArray(ComponentMod.routeModule.userland.loaderTree)) {
-                resolveParallelRouteParams(ComponentMod.routeModule.userland.loaderTree, params, pathname, fallbackRouteParams);
+                (0, _utils.resolveRouteParamsFromTree)(ComponentMod.routeModule.userland.loaderTree, params, route, fallbackRouteParams);
             }
             const fallbackRootParams = [];
-            for (const { paramName, isParallelRouteParam } of fallbackRouteParams){
-                // Only add the param to the fallback root params if it's not a
-                // parallel route param. They won't contribute to the request pathname.
-                if (isParallelRouteParam) continue;
+            for (const { paramName } of fallbackRouteParams){
                 // If the param is a root param then we can add it to the fallback
                 // root params.
                 if (rootParamSet.has(paramName)) {
@@ -812,7 +671,7 @@ async function buildAppStaticPaths({ dir, page, distDir, cacheComponents, authIn
     ] : undefined;
     // Now we have to set the throwOnEmptyStaticShell for each of the routes.
     if (prerenderedRoutes && cacheComponents) {
-        assignErrorIfEmpty(prerenderedRoutes, childrenRouteParamSegments);
+        assignErrorIfEmpty(prerenderedRoutes, pathnameRouteParamSegments);
     }
     return {
         fallbackMode,

qalita/_frontend/node_modules/next/dist/build/static-paths/utils.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    createFallbackRouteParam: null,
     encodeParam: null,
-    normalizePathname: null
+    extractPathnameRouteParamSegments: null,
+    extractPathnameRouteParamSegmentsFromSegments: null,
+    normalizePathname: null,
+    resolveRouteParamsFromTree: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -14,16 +16,27 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    createFallbackRouteParam: function() {
-        return createFallbackRouteParam;
-    },
     encodeParam: function() {
         return encodeParam;
     },
+    extractPathnameRouteParamSegments: function() {
+        return extractPathnameRouteParamSegments;
+    },
+    extractPathnameRouteParamSegmentsFromSegments: function() {
+        return extractPathnameRouteParamSegmentsFromSegments;
+    },
     normalizePathname: function() {
         return normalizePathname;
+    },
+    resolveRouteParamsFromTree: function() {
+        return resolveRouteParamsFromTree;
     }
 });
+const _checks = require("../../server/route-modules/checks");
+const _app = require("../../shared/lib/router/routes/app");
+const _parseloadertree = require("../../shared/lib/router/utils/parse-loader-tree");
+const _extractpathnamerouteparamsegmentsfromloadertree = require("./app/extract-pathname-route-param-segments-from-loader-tree");
+const _resolveparamvalue = require("../../shared/lib/router/utils/resolve-param-value");
 function encodeParam(value, encoder) {
     let replaceValue;
     if (Array.isArray(value)) {
@@ -36,12 +49,71 @@ function encodeParam(value, encoder) {
 function normalizePathname(pathname) {
     return pathname.replace(/\\/g, '/').replace(/(?!^)\/$/, '');
 }
-function createFallbackRouteParam(paramName, paramType, isParallelRouteParam) {
-    return {
-        paramName,
-        paramType,
-        isParallelRouteParam
-    };
+function extractPathnameRouteParamSegments(routeModule, segments, route) {
+    // For AppPageRouteModule, use the loaderTree traversal approach
+    if ((0, _checks.isAppPageRouteModule)(routeModule)) {
+        const { pathnameRouteParamSegments } = (0, _extractpathnamerouteparamsegmentsfromloadertree.extractPathnameRouteParamSegmentsFromLoaderTree)(routeModule.userland.loaderTree, route);
+        return pathnameRouteParamSegments;
+    }
+    return extractPathnameRouteParamSegmentsFromSegments(segments);
+}
+function extractPathnameRouteParamSegmentsFromSegments(segments) {
+    // TODO: should we consider what values are already present in the page?
+    // For AppRouteRouteModule, filter the segments array to get the route params
+    // that contribute to the pathname.
+    const result = [];
+    for (const segment of segments){
+        // Skip segments without param info.
+        if (!segment.paramName || !segment.paramType) continue;
+        // Collect all the route param keys that contribute to the pathname.
+        result.push({
+            name: segment.name,
+            paramName: segment.paramName,
+            paramType: segment.paramType
+        });
+    }
+    return result;
+}
+function resolveRouteParamsFromTree(loaderTree, params, route, fallbackRouteParams) {
+    // Stack-based traversal with depth tracking
+    const stack = [
+        {
+            tree: loaderTree,
+            depth: 0
+        }
+    ];
+    while(stack.length > 0){
+        const { tree, depth } = stack.pop();
+        const { segment, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+        const appSegment = (0, _app.parseAppRouteSegment)(segment);
+        // If this segment is a route parameter, then we should process it if it's
+        // not already known and is not already marked as a fallback route param.
+        if ((appSegment == null ? void 0 : appSegment.type) === 'dynamic' && !params.hasOwnProperty(appSegment.param.paramName) && !fallbackRouteParams.some((param)=>param.paramName === appSegment.param.paramName)) {
+            const { paramName, paramType } = appSegment.param;
+            const paramValue = (0, _resolveparamvalue.resolveParamValue)(paramName, paramType, depth, route, params);
+            if (paramValue !== undefined) {
+                params[paramName] = paramValue;
+            } else if (paramType !== 'optional-catchall') {
+                // If we couldn't resolve the param, mark it as a fallback
+                fallbackRouteParams.push({
+                    paramName,
+                    paramType
+                });
+            }
+        }
+        // Calculate next depth - increment if this is not a route group and not empty
+        let nextDepth = depth;
+        if (appSegment && appSegment.type !== 'route-group' && appSegment.type !== 'parallel-route') {
+            nextDepth++;
+        }
+        // Add all parallel routes to the stack for processing.
+        for (const parallelRoute of Object.values(parallelRoutes)){
+            stack.push({
+                tree: parallelRoute,
+                depth: nextDepth
+            });
+        }
+    }
 }
 
 //# sourceMappingURL=utils.js.map

qalita/_frontend/node_modules/next/dist/build/swc/index.js

@@ -130,7 +130,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const nextVersion = "16.0.10";
+const nextVersion = "16.1.1";
 const ArchName = (0, _os.arch)();
 const PlatformName = (0, _os.platform)();
 function infoLog(...args) {
@@ -453,6 +453,7 @@ function rustifyOptionEnv(env) {
             value
         }));
 }
+const normalizePathOnWindows = (p)=>_path.default.sep === '\\' ? p.replace(/\\/g, '/') : p;
 // TODO(sokra) Support wasm option.
 function bindingToApi(binding, _wasm) {
     const cancel = new class Cancel extends Error {
@@ -645,9 +646,9 @@ function bindingToApi(binding, _wasm) {
         let nextConfigSerializable = {
             ...nextConfig
         };
-        nextConfigSerializable.generateBuildId = await (nextConfigSerializable.generateBuildId == null ? void 0 : nextConfigSerializable.generateBuildId.call(nextConfigSerializable));
-        // TODO: these functions takes arguments, have to be supported in a different way
+        // These values are never read by Turbopack and are potentially non-serializable.
         nextConfigSerializable.exportPathMap = {};
+        nextConfigSerializable.generateBuildId = nextConfigSerializable.generateBuildId && {};
         nextConfigSerializable.webpack = nextConfigSerializable.webpack && {};
         if (nextConfigSerializable.modularizeImports) {
             nextConfigSerializable.modularizeImports = Object.fromEntries(Object.entries(nextConfigSerializable.modularizeImports).map(([mod, config])=>[
@@ -658,21 +659,24 @@ function bindingToApi(binding, _wasm) {
                     }
                 ]));
         }
+        // These are relative paths, but might be backslash-separated on Windows
+        nextConfigSerializable.distDir = normalizePathOnWindows(nextConfigSerializable.distDir);
+        nextConfigSerializable.distDirRoot = normalizePathOnWindows(nextConfigSerializable.distDirRoot);
         // loaderFile is an absolute path, we need it to be relative for turbopack.
         if (nextConfigSerializable.images.loaderFile) {
             nextConfigSerializable.images = {
                 ...nextConfigSerializable.images,
-                loaderFile: './' + _path.default.relative(projectPath, nextConfigSerializable.images.loaderFile)
+                loaderFile: './' + normalizePathOnWindows(_path.default.relative(projectPath, nextConfigSerializable.images.loaderFile))
             };
         }
         // cacheHandler can be an absolute path, we need it to be relative for turbopack.
         if (nextConfigSerializable.cacheHandler) {
-            nextConfigSerializable.cacheHandler = './' + (_path.default.isAbsolute(nextConfigSerializable.cacheHandler) ? _path.default.relative(projectPath, nextConfigSerializable.cacheHandler) : nextConfigSerializable.cacheHandler);
+            nextConfigSerializable.cacheHandler = './' + normalizePathOnWindows(_path.default.isAbsolute(nextConfigSerializable.cacheHandler) ? _path.default.relative(projectPath, nextConfigSerializable.cacheHandler) : nextConfigSerializable.cacheHandler);
         }
         if (nextConfigSerializable.cacheHandlers) {
             nextConfigSerializable.cacheHandlers = Object.fromEntries(Object.entries(nextConfigSerializable.cacheHandlers).filter(([_, value])=>value != null).map(([key, value])=>[
                     key,
-                    './' + (_path.default.isAbsolute(value) ? _path.default.relative(projectPath, value) : value)
+                    './' + normalizePathOnWindows(_path.default.isAbsolute(value) ? _path.default.relative(projectPath, value) : value)
                 ]));
         }
         if (nextConfigSerializable.turbopack != null) {