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

qalita/_frontend/node_modules/next/dist/build/segment-config/app/app-segments.js

@@ -2,21 +2,9 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-0 && (module.exports = {
-    collectFallbackRouteParams: null,
-    collectSegments: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    collectFallbackRouteParams: function() {
-        return collectFallbackRouteParams;
-    },
-    collectSegments: function() {
+Object.defineProperty(exports, "collectSegments", {
+    enumerable: true,
+    get: function() {
         return collectSegments;
     }
 });
@@ -26,8 +14,6 @@ const _checks = require("../../../server/route-modules/checks");
 const _clientandserverreferences = require("../../../lib/client-and-server-references");
 const _getsegmentparam = require("../../../shared/lib/router/utils/get-segment-param");
 const _appdirmodule = require("../../../server/lib/app-dir-module");
-const _segment = require("../../../shared/lib/segment");
-const _utils = require("../../static-paths/utils");
 /**
  * Parses the app config and attaches it to the segment.
  */ function attach(segment, userland, route) {
@@ -62,70 +48,42 @@ const _utils = require("../../static-paths/utils");
  */ async function collectAppPageSegments(routeModule) {
     // We keep track of unique segments, since with parallel routes, it's possible
     // to see the same segment multiple times.
-    const uniqueSegments = new Map();
+    const segments = [];
+    // Queue will store loader trees.
     const queue = [
-        [
-            routeModule.userland.loaderTree,
-            [],
-            false
-        ]
+        routeModule.userland.loaderTree
     ];
     while(queue.length > 0){
-        const [loaderTree, currentSegments, isParallelRouteSegment] = queue.shift();
+        const loaderTree = queue.shift();
         const [name, parallelRoutes] = loaderTree;
         // Process current node
         const { mod: userland, filePath } = await (0, _appdirmodule.getLayoutOrPageModule)(loaderTree);
         const isClientComponent = userland && (0, _clientandserverreferences.isClientReference)(userland);
-        const { param: paramName, type: paramType } = (0, _getsegmentparam.getSegmentParam)(name) ?? {};
+        const param = (0, _getsegmentparam.getSegmentParam)(name);
         const segment = {
             name,
-            paramName,
-            paramType,
+            paramName: param == null ? void 0 : param.paramName,
+            paramType: param == null ? void 0 : param.paramType,
             filePath,
             config: undefined,
-            isDynamicSegment: !!paramName,
-            generateStaticParams: undefined,
-            isParallelRouteSegment
+            generateStaticParams: undefined
         };
         // Only server components can have app segment configurations
         if (!isClientComponent) {
             attach(segment, userland, routeModule.definition.pathname);
         }
-        // Create a unique key for the segment
-        const segmentKey = getSegmentKey(segment);
-        if (!uniqueSegments.has(segmentKey)) {
-            uniqueSegments.set(segmentKey, segment);
-        }
-        const updatedSegments = [
-            ...currentSegments,
-            segment
-        ];
-        // If this is a page segment, we've reached a leaf node
-        if (name === _segment.PAGE_SEGMENT_KEY) {
-            // Add all segments in the current path, preferring non-parallel segments
-            updatedSegments.forEach((seg)=>{
-                const key = getSegmentKey(seg);
-                if (!uniqueSegments.has(key)) {
-                    uniqueSegments.set(key, seg);
-                }
-            });
+        // If this segment doesn't already exist, then add it to the segments array.
+        // The list of segments is short so we just use a list traversal to check
+        // for duplicates and spare us needing to maintain the string key.
+        if (segments.every((s)=>s.name !== segment.name || s.paramName !== segment.paramName || s.paramType !== segment.paramType || s.filePath !== segment.filePath)) {
+            segments.push(segment);
         }
         // Add all parallel routes to the queue
-        for(const parallelRouteKey in parallelRoutes){
-            const parallelRoute = parallelRoutes[parallelRouteKey];
-            queue.push([
-                parallelRoute,
-                updatedSegments,
-                // A parallel route segment is one that descends from a segment that is
-                // not children or descends from a parallel route segment.
-                isParallelRouteSegment || parallelRouteKey !== 'children'
-            ]);
+        for (const parallelRoute of Object.values(parallelRoutes)){
+            queue.push(parallelRoute);
         }
     }
-    return Array.from(uniqueSegments.values());
-}
-function getSegmentKey(segment) {
-    return `${segment.name}-${segment.filePath ?? ''}-${segment.paramName ?? ''}-${segment.isParallelRouteSegment ? 'pr' : 'np'}`;
+    return segments;
 }
 /**
  * Collects the segments for a given app route module.
@@ -144,16 +102,14 @@ function getSegmentKey(segment) {
     }
     // Generate all the segments.
     const segments = parts.map((name)=>{
-        const { param: paramName, type: paramType } = (0, _getsegmentparam.getSegmentParam)(name) ?? {};
+        const param = (0, _getsegmentparam.getSegmentParam)(name);
         return {
             name,
-            paramName,
-            paramType,
+            paramName: param == null ? void 0 : param.paramName,
+            paramType: param == null ? void 0 : param.paramType,
             filePath: undefined,
-            isDynamicSegment: !!paramName,
             config: undefined,
-            generateStaticParams: undefined,
-            isParallelRouteSegment: undefined
+            generateStaticParams: undefined
         };
     });
     // We know we have at least one, we verified this above. We should get the
@@ -177,37 +133,5 @@ function collectSegments(routeModule) {
         configurable: true
     });
 }
-function collectFallbackRouteParams(routeModule) {
-    const uniqueSegments = new Map();
-    const queue = [
-        [
-            routeModule.userland.loaderTree,
-            false
-        ]
-    ];
-    while(queue.length > 0){
-        const [loaderTree, isParallelRouteSegment] = queue.shift();
-        const [name, parallelRoutes] = loaderTree;
-        // Handle this segment (if it's a dynamic segment param).
-        const segmentParam = (0, _getsegmentparam.getSegmentParam)(name);
-        if (segmentParam) {
-            const key = `${name}-${segmentParam.param}-${isParallelRouteSegment ? 'pr' : 'np'}`;
-            if (!uniqueSegments.has(key)) {
-                uniqueSegments.set(key, (0, _utils.createFallbackRouteParam)(segmentParam.param, segmentParam.type, isParallelRouteSegment));
-            }
-        }
-        // Add all of this segment's parallel routes to the queue.
-        for(const parallelRouteKey in parallelRoutes){
-            const parallelRoute = parallelRoutes[parallelRouteKey];
-            queue.push([
-                parallelRoute,
-                // A parallel route segment is one that descends from a segment that is
-                // not children or descends from a parallel route segment.
-                isParallelRouteSegment || parallelRouteKey !== 'children'
-            ]);
-        }
-    }
-    return Array.from(uniqueSegments.values());
-}
 
 //# sourceMappingURL=app-segments.js.map

qalita/_frontend/node_modules/next/dist/build/segment-config/app/collect-root-param-keys.js

@@ -18,9 +18,9 @@ function collectAppPageRootParamKeys(routeModule) {
         var _getSegmentParam;
         const [name, parallelRoutes, modules] = current;
         // If this is a dynamic segment, then we collect the param.
-        const param = (_getSegmentParam = (0, _getsegmentparam.getSegmentParam)(name)) == null ? void 0 : _getSegmentParam.param;
-        if (param) {
-            rootParams.push(param);
+        const paramName = (_getSegmentParam = (0, _getsegmentparam.getSegmentParam)(name)) == null ? void 0 : _getSegmentParam.paramName;
+        if (paramName) {
+            rootParams.push(paramName);
         }
         // If this has a layout module, then we've found the root layout because
         // we return once we found the first layout.

qalita/_frontend/node_modules/next/dist/build/spinner.js

@@ -66,7 +66,7 @@ const dotsSpinner = {
 };
 function createSpinner(text, options = {}, logFn = console.log) {
     let spinner;
-    let prefixText = ` ${_log.prefixes.info} ${text} `;
+    let prefixText = `${_log.prefixes.info} ${text} `;
     if (process.stdout.isTTY) {
         spinner = (0, _ora.default)({
             text: undefined,
@@ -108,7 +108,7 @@ function createSpinner(text, options = {}, logFn = console.log) {
         };
         spinner.setText = (newText)=>{
             text = newText;
-            prefixText = ` ${_log.prefixes.info} ${newText} `;
+            prefixText = `${_log.prefixes.info} ${newText} `;
             spinner.prefixText = prefixText;
             return spinner;
         };
@@ -119,7 +119,7 @@ function createSpinner(text, options = {}, logFn = console.log) {
         };
         spinner.stopAndPersist = ()=>{
             // Add \r at beginning to reset the current line of loading status text
-            const suffixText = `\r ${_log.prefixes.event} ${text} `;
+            const suffixText = `\r${_log.prefixes.event} ${text} `;
             if (spinner) {
                 spinner.text = suffixText;
             } else {

qalita/_frontend/node_modules/next/dist/build/static-paths/app/extract-pathname-route-param-segments-from-loader-tree.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "extractPathnameRouteParamSegmentsFromLoaderTree", {
+    enumerable: true,
+    get: function() {
+        return extractPathnameRouteParamSegmentsFromLoaderTree;
+    }
+});
+const _app = require("../../../shared/lib/router/routes/app");
+const _parseloadertree = require("../../../shared/lib/router/utils/parse-loader-tree");
+const _resolveparamvalue = require("../../../shared/lib/router/utils/resolve-param-value");
+/**
+ * Validates that the static segments in currentPath match the corresponding
+ * segments in targetSegments. This ensures we only extract dynamic parameters
+ * that are part of the target pathname structure.
+ *
+ * Segments are compared literally - interception markers like "(.)photo" are
+ * part of the pathname and must match exactly.
+ *
+ * @example
+ * // Matching paths
+ * currentPath: ['blog', '(.)photo']
+ * targetSegments: ['blog', '(.)photo', '[id]']
+ * → Returns true (both static segments match exactly)
+ *
+ * @example
+ * // Non-matching paths
+ * currentPath: ['blog', '(.)photo']
+ * targetSegments: ['blog', 'photo', '[id]']
+ * → Returns false (segments don't match - marker is part of pathname)
+ *
+ * @param currentPath - The accumulated path segments from the loader tree
+ * @param targetSegments - The target pathname split into segments
+ * @returns true if all static segments match, false otherwise
+ */ function validatePrefixMatch(currentPath, route) {
+    for(let i = 0; i < currentPath.length; i++){
+        const pathSegment = currentPath[i];
+        const targetPathSegment = route.segments[i];
+        // Type mismatch - one is static, one is dynamic
+        if (pathSegment.type !== targetPathSegment.type) {
+            return false;
+        }
+        // One has an interception marker, the other doesn't.
+        if (pathSegment.interceptionMarker !== targetPathSegment.interceptionMarker) {
+            return false;
+        }
+        // Both are static but names don't match
+        if (pathSegment.type === 'static' && targetPathSegment.type === 'static' && pathSegment.name !== targetPathSegment.name) {
+            return false;
+        } else if (pathSegment.type === 'dynamic' && targetPathSegment.type === 'dynamic' && pathSegment.param.paramType !== targetPathSegment.param.paramType && pathSegment.param.paramName !== targetPathSegment.param.paramName) {
+            return false;
+        }
+    }
+    return true;
+}
+function extractPathnameRouteParamSegmentsFromLoaderTree(loaderTree, route) {
+    const pathnameRouteParamSegments = [];
+    const params = {};
+    // BFS traversal with depth and path tracking
+    const queue = [
+        {
+            tree: loaderTree,
+            depth: 0,
+            currentPath: []
+        }
+    ];
+    while(queue.length > 0){
+        const { tree, depth, currentPath } = queue.shift();
+        const { segment, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+        // Build the path for the current node
+        let updatedPath = currentPath;
+        let nextDepth = depth;
+        const appSegment = (0, _app.parseAppRouteSegment)(segment);
+        // Only add to path if it's a real segment that appears in the URL
+        // Route groups and parallel markers don't contribute to URL pathname
+        if (appSegment && appSegment.type !== 'route-group' && appSegment.type !== 'parallel-route') {
+            updatedPath = [
+                ...currentPath,
+                appSegment
+            ];
+            nextDepth = depth + 1;
+        }
+        // Check if this segment has a param and matches the target pathname at this depth
+        if ((appSegment == null ? void 0 : appSegment.type) === 'dynamic') {
+            const { paramName, paramType } = appSegment.param;
+            // Check if this segment is at the correct depth in the target pathname
+            // A segment matches if:
+            // 1. There's a dynamic segment at this depth in the pathname
+            // 2. The parameter names match (e.g., [id] matches [id], not [category])
+            // 3. The static segments leading up to this point match (prefix check)
+            if (depth < route.segments.length) {
+                const targetSegment = route.segments[depth];
+                // Match if the target pathname has a dynamic segment at this depth
+                if (targetSegment.type === 'dynamic') {
+                    // Check that parameter names match exactly
+                    // This prevents [category] from matching against /[id]
+                    if (paramName !== targetSegment.param.paramName) {
+                        continue; // Different param names, skip this segment
+                    }
+                    // Validate that the path leading up to this dynamic segment matches
+                    // the target pathname. This prevents false matches like extracting
+                    // [slug] from "/news/[slug]" when the tree has "/blog/[slug]"
+                    if (validatePrefixMatch(currentPath, route)) {
+                        pathnameRouteParamSegments.push({
+                            name: segment,
+                            paramName,
+                            paramType
+                        });
+                    }
+                }
+            }
+            // Resolve parameter value if it's not already known.
+            if (!params.hasOwnProperty(paramName)) {
+                const paramValue = (0, _resolveparamvalue.resolveParamValue)(paramName, paramType, depth, route, params);
+                if (paramValue !== undefined) {
+                    params[paramName] = paramValue;
+                }
+            }
+        }
+        // Continue traversing all parallel routes to find matching segments
+        for (const parallelRoute of Object.values(parallelRoutes)){
+            queue.push({
+                tree: parallelRoute,
+                depth: nextDepth,
+                currentPath: updatedPath
+            });
+        }
+    }
+    return {
+        pathnameRouteParamSegments,
+        params
+    };
+}
+
+//# sourceMappingURL=extract-pathname-route-param-segments-from-loader-tree.js.map