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

qalita/_frontend/node_modules/next/dist/server/app-render/use-flight-response.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     createInlinedDataReadableStream: null,
-    useFlightStream: null
+    getFlightStream: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -16,13 +16,14 @@ _export(exports, {
     createInlinedDataReadableStream: function() {
         return createInlinedDataReadableStream;
     },
-    useFlightStream: function() {
-        return useFlightStream;
+    getFlightStream: function() {
+        return getFlightStream;
     }
 });
 const _htmlescape = require("../htmlescape");
 const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
 const _invarianterror = require("../../shared/lib/invariant-error");
+const _manifestssingleton = require("./manifests-singleton");
 const isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge';
 const INLINE_FLIGHT_PAYLOAD_BOOTSTRAP = 0;
 const INLINE_FLIGHT_PAYLOAD_DATA = 1;
@@ -31,26 +32,70 @@ const INLINE_FLIGHT_PAYLOAD_BINARY = 3;
 const flightResponses = new WeakMap();
 const encoder = new TextEncoder();
 const findSourceMapURL = process.env.NODE_ENV !== 'production' ? require('../lib/source-maps').findSourceMapURLDEV : undefined;
-function useFlightStream(flightStream, debugStream, clientReferenceManifest, nonce) {
+function getFlightStream(flightStream, debugStream, debugEndTime, nonce) {
     const response = flightResponses.get(flightStream);
     if (response) {
         return response;
     }
-    // react-server-dom-webpack/client.edge must not be hoisted for require cache clearing to work correctly
-    const { createFromReadableStream } = // eslint-disable-next-line import/no-extraneous-dependencies
-    require('react-server-dom-webpack/client');
-    const newResponse = createFromReadableStream(flightStream, {
-        findSourceMapURL,
-        serverConsumerManifest: {
-            moduleLoading: clientReferenceManifest.moduleLoading,
-            moduleMap: isEdgeRuntime ? clientReferenceManifest.edgeSSRModuleMapping : clientReferenceManifest.ssrModuleMapping,
-            serverModuleMap: null
-        },
-        nonce,
-        debugChannel: debugStream ? {
-            readable: debugStream
-        } : undefined
-    });
+    const { moduleLoading, edgeSSRModuleMapping, ssrModuleMapping } = (0, _manifestssingleton.getClientReferenceManifest)();
+    let newResponse;
+    if (flightStream instanceof ReadableStream) {
+        // The types of flightStream and debugStream should match.
+        if (debugStream && !(debugStream instanceof ReadableStream)) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('Expected debug stream to be a ReadableStream'), "__NEXT_ERROR_CODE", {
+                value: "E939",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        // react-server-dom-webpack/client.edge must not be hoisted for require cache clearing to work correctly
+        const { createFromReadableStream } = // eslint-disable-next-line import/no-extraneous-dependencies
+        require('react-server-dom-webpack/client');
+        newResponse = createFromReadableStream(flightStream, {
+            findSourceMapURL,
+            serverConsumerManifest: {
+                moduleLoading,
+                moduleMap: isEdgeRuntime ? edgeSSRModuleMapping : ssrModuleMapping,
+                serverModuleMap: null
+            },
+            nonce,
+            debugChannel: debugStream ? {
+                readable: debugStream
+            } : undefined,
+            endTime: debugEndTime
+        });
+    } else {
+        if (process.env.NEXT_RUNTIME === 'edge') {
+            throw Object.defineProperty(new _invarianterror.InvariantError('getFlightStream should always receive a ReadableStream when using the edge runtime'), "__NEXT_ERROR_CODE", {
+                value: "E943",
+                enumerable: false,
+                configurable: true
+            });
+        } else {
+            const { Readable } = require('node:stream');
+            // The types of flightStream and debugStream should match.
+            if (debugStream && !(debugStream instanceof Readable)) {
+                throw Object.defineProperty(new _invarianterror.InvariantError('Expected debug stream to be a Readable'), "__NEXT_ERROR_CODE", {
+                    value: "E940",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            // react-server-dom-webpack/client.edge must not be hoisted for require cache clearing to work correctly
+            const { createFromNodeStream } = // eslint-disable-next-line import/no-extraneous-dependencies
+            require('react-server-dom-webpack/client');
+            newResponse = createFromNodeStream(flightStream, {
+                moduleLoading,
+                moduleMap: isEdgeRuntime ? edgeSSRModuleMapping : ssrModuleMapping,
+                serverModuleMap: null
+            }, {
+                findSourceMapURL,
+                nonce,
+                debugChannel: debugStream,
+                endTime: debugEndTime
+            });
+        }
+    }
     // Edge pages are never prerendered so they necessarily cannot have a workUnitStore type
     // that requires the nextTick behavior. This is why it is safe to access a node only API here
     if (process.env.NEXT_RUNTIME !== 'edge') {
@@ -65,7 +110,9 @@ function useFlightStream(flightStream, debugStream, clientReferenceManifest, non
         switch(workUnitStore.type){
             case 'prerender-client':
                 const responseOnNextTick = new Promise((resolve)=>{
-                    process.nextTick(()=>resolve(newResponse));
+                    process.nextTick(()=>{
+                        resolve(newResponse);
+                    });
                 });
                 flightResponses.set(flightStream, responseOnNextTick);
                 return responseOnNextTick;

qalita/_frontend/node_modules/next/dist/server/app-render/walk-tree-with-flight-router-state.js

@@ -140,7 +140,7 @@ async function walkTreeWithFlightRouterState({ loaderTreeToFilter, parentParams,
     const injectedJSWithCurrentLayout = new Set(injectedJS);
     const injectedFontPreloadTagsWithCurrentLayout = new Set(injectedFontPreloadTags);
     if (layoutPath) {
-        (0, _getcssinlinedlinktags.getLinkAndScriptTags)(ctx.clientReferenceManifest, layoutPath, injectedCSSWithCurrentLayout, injectedJSWithCurrentLayout, true);
+        (0, _getcssinlinedlinktags.getLinkAndScriptTags)(layoutPath, injectedCSSWithCurrentLayout, injectedJSWithCurrentLayout, true);
         (0, _getpreloadablefonts.getPreloadableFonts)(nextFontManifest, layoutPath, injectedFontPreloadTagsWithCurrentLayout);
     }
     const paths = [];
@@ -179,7 +179,7 @@ async function walkTreeWithFlightRouterState({ loaderTreeToFilter, parentParams,
     if (Array.isArray(existingSegment) || !Array.isArray(segment)) {
         return false;
     }
-    return ((_getSegmentParam = (0, _getsegmentparam.getSegmentParam)(existingSegment)) == null ? void 0 : _getSegmentParam.param) === segment[0];
+    return ((_getSegmentParam = (0, _getsegmentparam.getSegmentParam)(existingSegment)) == null ? void 0 : _getSegmentParam.paramName) === segment[0];
 };
 
 //# sourceMappingURL=walk-tree-with-flight-router-state.js.map

qalita/_frontend/node_modules/next/dist/server/async-storage/work-store.js

@@ -60,7 +60,8 @@ function createWorkStore({ page, renderOpts, isPrefetchRequest, buildId, previou
         previouslyRevalidatedTags,
         refreshTagsByCacheKind: createRefreshTagsByCacheKind(),
         runInCleanSnapshot: (0, _asynclocalstorage.createSnapshot)(),
-        shouldTrackFetchMetrics
+        shouldTrackFetchMetrics,
+        reactServerErrorsByDigest: new Map()
     };
     // TODO: remove this when we resolve accessing the store outside the execution context
     renderOpts.store = store;

qalita/_frontend/node_modules/next/dist/server/base-server.js

@@ -60,7 +60,6 @@ const _getroutefromassetpath = /*#__PURE__*/ _interop_require_default(require(".
 const _rsc = require("./normalizers/request/rsc");
 const _stripflightheaders = require("./app-render/strip-flight-headers");
 const _checks = require("./route-modules/checks");
-const _prefetchrsc = require("./normalizers/request/prefetch-rsc");
 const _nextdata = require("./normalizers/request/next-data");
 const _serveractionrequestmeta = require("./lib/server-action-request-meta");
 const _interceptionroutes = require("../shared/lib/router/utils/interception-routes");
@@ -143,7 +142,7 @@ class Server {
    */ constructor(options){
         var _this_nextConfig_i18n, _this_nextConfig_i18n1;
         this.handleRSCRequest = (req, _res, parsedUrl)=>{
-            var _this_normalizers_segmentPrefetchRSC, _this_normalizers_prefetchRSC, _this_normalizers_rsc;
+            var _this_normalizers_segmentPrefetchRSC, _this_normalizers_rsc;
             if (!parsedUrl.pathname) return false;
             if ((_this_normalizers_segmentPrefetchRSC = this.normalizers.segmentPrefetchRSC) == null ? void 0 : _this_normalizers_segmentPrefetchRSC.match(parsedUrl.pathname)) {
                 const result = this.normalizers.segmentPrefetchRSC.extract(parsedUrl.pathname);
@@ -157,13 +156,6 @@ class Server {
                 (0, _requestmeta.addRequestMeta)(req, 'isRSCRequest', true);
                 (0, _requestmeta.addRequestMeta)(req, 'isPrefetchRSCRequest', true);
                 (0, _requestmeta.addRequestMeta)(req, 'segmentPrefetchRSCRequest', segmentPath);
-            } else if ((_this_normalizers_prefetchRSC = this.normalizers.prefetchRSC) == null ? void 0 : _this_normalizers_prefetchRSC.match(parsedUrl.pathname)) {
-                parsedUrl.pathname = this.normalizers.prefetchRSC.normalize(parsedUrl.pathname, true);
-                // Mark the request as a router prefetch request.
-                req.headers[_approuterheaders.RSC_HEADER] = '1';
-                req.headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] = '1';
-                (0, _requestmeta.addRequestMeta)(req, 'isRSCRequest', true);
-                (0, _requestmeta.addRequestMeta)(req, 'isPrefetchRSCRequest', true);
             } else if ((_this_normalizers_rsc = this.normalizers.rsc) == null ? void 0 : _this_normalizers_rsc.match(parsedUrl.pathname)) {
                 parsedUrl.pathname = this.normalizers.rsc.normalize(parsedUrl.pathname, true);
                 // Mark the request as a RSC request.
@@ -284,11 +276,6 @@ class Server {
             if (this.normalizers.segmentPrefetchRSC) {
                 normalizers.push(this.normalizers.segmentPrefetchRSC);
             }
-            // We have to put the prefetch normalizer before the RSC normalizer
-            // because the RSC normalizer will match the prefetch RSC routes too.
-            if (this.normalizers.prefetchRSC) {
-                normalizers.push(this.normalizers.prefetchRSC);
-            }
             if (this.normalizers.rsc) {
                 normalizers.push(this.normalizers.rsc);
             }
@@ -324,6 +311,21 @@ class Server {
         // TODO: should conf be normalized to prevent missing
         // values from causing issues as this can be user provided
         this.nextConfig = conf;
+        let deploymentId;
+        if (this.nextConfig.experimental.runtimeServerDeploymentId) {
+            if (!process.env.NEXT_DEPLOYMENT_ID) {
+                throw Object.defineProperty(new Error('process.env.NEXT_DEPLOYMENT_ID is missing but runtimeServerDeploymentId is enabled'), "__NEXT_ERROR_CODE", {
+                    value: "E970",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            deploymentId = process.env.NEXT_DEPLOYMENT_ID;
+        } else {
+            let id = this.nextConfig.experimental.useSkewCookie ? '' : this.nextConfig.deploymentId || '';
+            deploymentId = id;
+            process.env.NEXT_DEPLOYMENT_ID = id;
+        }
         this.hostname = hostname;
         if (this.hostname) {
             // we format the hostname so that it can be fetched
@@ -349,17 +351,15 @@ class Server {
             // mode as otherwise that route is not exposed external to the server as
             // we instead only rely on the headers.
             rsc: this.enabledDirectories.app && this.minimalMode ? new _rsc.RSCPathnameNormalizer() : undefined,
-            prefetchRSC: this.isAppPPREnabled && this.minimalMode ? new _prefetchrsc.PrefetchRSCPathnameNormalizer() : undefined,
             segmentPrefetchRSC: this.minimalMode ? new _segmentprefixrsc.SegmentPrefixRSCPathnameNormalizer() : undefined,
             data: this.enabledDirectories.pages ? new _nextdata.NextDataPathnameNormalizer(this.buildId) : undefined
         };
         this.nextFontManifest = this.getNextFontManifest();
-        process.env.NEXT_DEPLOYMENT_ID = this.nextConfig.deploymentId || '';
         this.renderOpts = {
             dir: this.dir,
             supportsDynamicResponse: true,
             trailingSlash: this.nextConfig.trailingSlash,
-            deploymentId: this.nextConfig.deploymentId,
+            deploymentId: deploymentId,
             poweredByHeader: this.nextConfig.poweredByHeader,
             generateEtags,
             previewProps: this.getPrerenderManifest().preview,
@@ -403,9 +403,6 @@ class Server {
         // wait. Also we can't `await` in the constructor.
         void this.matchers.reload();
         this.setAssetPrefix(assetPrefix);
-        this.responseCache = this.getResponseCache({
-            dev
-        });
     }
     reloadMatchers() {
         return this.matchers.reload();
@@ -1326,6 +1323,11 @@ class Server {
         // TODO: investigate, this is not safe across multiple concurrent requests
         incrementalCache.resetRequestCache();
         if ((routeModule == null ? void 0 : routeModule.isDev) && (0, _utils1.isDynamicRoute)(pathname) && (components.getStaticPaths || isAppPath)) {
+            var _pathsResults_staticPaths;
+            let getStaticPathsStart;
+            if (opts.dev) {
+                getStaticPathsStart = process.hrtime.bigint();
+            }
             const pathsResults = await this.getStaticPaths({
                 pathname,
                 urlPathname,
@@ -1333,6 +1335,9 @@ class Server {
                 page: components.page,
                 isAppPath
             });
+            if (opts.dev && getStaticPathsStart && ((_pathsResults_staticPaths = pathsResults.staticPaths) == null ? void 0 : _pathsResults_staticPaths.length)) {
+                (0, _requestmeta.addRequestMeta)(req, 'devGenerateStaticParamsDuration', process.hrtime.bigint() - getStaticPathsStart);
+            }
             if (isAppPath && this.nextConfig.cacheComponents) {
                 var _pathsResults_prerenderedRoutes;
                 if ((_pathsResults_prerenderedRoutes = pathsResults.prerenderedRoutes) == null ? void 0 : _pathsResults_prerenderedRoutes.length) {
@@ -1367,7 +1372,6 @@ class Server {
         let initPathname = parsedInitUrl.pathname || '/';
         for (const normalizer of [
             this.normalizers.segmentPrefetchRSC,
-            this.normalizers.prefetchRSC,
             this.normalizers.rsc
         ]){
             if (normalizer == null ? void 0 : normalizer.match(initPathname)) {
@@ -1389,7 +1393,6 @@ class Server {
         if (opts.err) {
             (0, _requestmeta.addRequestMeta)(request, 'invokeError', opts.err);
         }
-        const handler = components.ComponentMod.handler;
         const maybeDevRequest = // we need to capture fetch metrics when they are set
         // and can't wait for handler to resolve as the fetch
         // metrics are logged on response close which happens
@@ -1410,7 +1413,13 @@ class Server {
                 return true;
             }
         }) : request;
-        await handler(maybeDevRequest, response, {
+        // @ts-expect-error This isn't entirely correct, but the ServerRequest type param seems overly
+        // generic anyway.
+        let handlerReq = maybeDevRequest;
+        // @ts-expect-error This isn't entirely correct, but the ServerResponse type param seems overly
+        // generic anyway.
+        let handlerRes = response;
+        await components.ComponentMod.handler(handlerReq, handlerRes, {
             waitUntil: this.getWaitUntil()
         });
         // response is handled fully in handler