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

qalita/_frontend/node_modules/@next/env/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next/env",
-  "version": "16.0.10",
+  "version": "16.1.1",
   "keywords": [
     "react",
     "next",
@@ -22,10 +22,10 @@
   ],
   "scripts": {
     "dev": "ncc build ./index.ts -w -o dist/",
-    "prerelease": "node ../../scripts/rm.mjs dist",
+    "prebuild:source": "node ../../scripts/rm.mjs dist",
     "types": "tsc --declaration --emitDeclarationOnly --declarationDir dist",
-    "release": "ncc build ./index.ts -o ./dist/ --minify --no-cache --no-source-map-register",
-    "build": "pnpm release && pnpm types",
+    "build:source": "ncc build ./index.ts -o ./dist/ --minify --no-cache --no-source-map-register",
+    "build": "pnpm build:source && pnpm types",
     "prepublishOnly": "cd ../../ && turbo run build"
   },
   "devDependencies": {

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

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return analyze;
+    }
+});
+const _trace = require("../../trace");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../output/log"));
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _config = /*#__PURE__*/ _interop_require_default(require("../../server/config"));
+const _constants = require("../../shared/lib/constants");
+const _turbopackanalyze = require("../turbopack-analyze");
+const _durationtostring = require("../duration-to-string");
+const _promises = require("node:fs/promises");
+const _entries = require("../entries");
+const _findpagefile = require("../../server/lib/find-page-file");
+const _findpagesdir = require("../../lib/find-pages-dir");
+const _pagetypes = require("../../lib/page-types");
+const _loadcustomroutes = /*#__PURE__*/ _interop_require_default(require("../../lib/load-custom-routes"));
+const _generateroutesmanifest = require("../generate-routes-manifest");
+const _ppr = require("../../server/lib/experimental/ppr");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _nodehttp = /*#__PURE__*/ _interop_require_default(require("node:http"));
+const _servehandler = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/serve-handler"));
+const _storage = require("../../telemetry/storage");
+const _events = require("../../telemetry/events");
+const _shared = require("../../trace/shared");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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;
+}
+async function analyze({ dir, reactProductionProfiling = false, noMangling = false, appDirOnly = false, output = false, port = 4000 }) {
+    try {
+        const config = await (0, _config.default)(_constants.PHASE_ANALYZE, dir, {
+            silent: false,
+            reactProductionProfiling
+        });
+        process.env.NEXT_DEPLOYMENT_ID = config.deploymentId || '';
+        const distDir = _nodepath.join(dir, '.next');
+        const telemetry = new _storage.Telemetry({
+            distDir
+        });
+        (0, _trace.setGlobal)('phase', _constants.PHASE_ANALYZE);
+        (0, _trace.setGlobal)('distDir', distDir);
+        (0, _trace.setGlobal)('telemetry', telemetry);
+        _log.info('Analyzing a production build...');
+        const analyzeContext = {
+            config,
+            dir,
+            distDir,
+            noMangling,
+            appDirOnly
+        };
+        const { duration: analyzeDuration, shutdownPromise } = await (0, _turbopackanalyze.turbopackAnalyze)(analyzeContext);
+        const durationString = (0, _durationtostring.durationToString)(analyzeDuration);
+        const analyzeDir = _nodepath.join(distDir, 'diagnostics/analyze');
+        await shutdownPromise;
+        const routes = await collectRoutesForAnalyze(dir, config, appDirOnly);
+        await (0, _promises.cp)(_nodepath.join(__dirname, '../../bundle-analyzer'), analyzeDir, {
+            recursive: true
+        });
+        await (0, _promises.mkdir)(_nodepath.join(analyzeDir, 'data'), {
+            recursive: true
+        });
+        await (0, _promises.writeFile)(_nodepath.join(analyzeDir, 'data', 'routes.json'), JSON.stringify(routes, null, 2));
+        let logMessage = `Analyze completed in ${durationString}.`;
+        if (output) {
+            logMessage += ` Results written to ${analyzeDir}.\nTo explore the analyze results interactively, run \`next experimental-analyze\` without \`--output\`.`;
+        }
+        _log.event(logMessage);
+        telemetry.record((0, _events.eventAnalyzeCompleted)({
+            success: true,
+            durationInSeconds: Math.round(analyzeDuration),
+            totalPageCount: routes.length
+        }));
+        if (!output) {
+            await startServer(analyzeDir, port);
+        }
+    } catch (e) {
+        const telemetry = _shared.traceGlobals.get('telemetry');
+        if (telemetry) {
+            telemetry.record((0, _events.eventAnalyzeCompleted)({
+                success: false
+            }));
+        }
+        throw e;
+    }
+}
+/**
+ * Collects all routes from the project for the bundle analyzer.
+ * Returns a list of route paths (both static and dynamic).
+ */ async function collectRoutesForAnalyze(dir, config, appDirOnly) {
+    const { pagesDir, appDir } = (0, _findpagesdir.findPagesDir)(dir);
+    const validFileMatcher = (0, _findpagefile.createValidFileMatcher)(config.pageExtensions, appDir);
+    let appType;
+    if (pagesDir && appDir) {
+        appType = 'hybrid';
+    } else if (pagesDir) {
+        appType = 'pages';
+    } else if (appDir) {
+        appType = 'app';
+    } else {
+        throw Object.defineProperty(new Error('No pages or app directory found.'), "__NEXT_ERROR_CODE", {
+            value: "E929",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const { appPaths } = appDir ? await (0, _entries.collectAppFiles)(appDir, validFileMatcher) : {
+        appPaths: []
+    };
+    const pagesPaths = pagesDir ? await (0, _entries.collectPagesFiles)(pagesDir, validFileMatcher) : null;
+    const appMapping = await (0, _entries.createPagesMapping)({
+        pagePaths: appPaths,
+        isDev: false,
+        pagesType: _pagetypes.PAGE_TYPES.APP,
+        pageExtensions: config.pageExtensions,
+        pagesDir,
+        appDir,
+        appDirOnly
+    });
+    const pagesMapping = pagesPaths ? await (0, _entries.createPagesMapping)({
+        pagePaths: pagesPaths,
+        isDev: false,
+        pagesType: _pagetypes.PAGE_TYPES.PAGES,
+        pageExtensions: config.pageExtensions,
+        pagesDir,
+        appDir,
+        appDirOnly
+    }) : null;
+    const pageKeys = {
+        pages: pagesMapping ? Object.keys(pagesMapping) : [],
+        app: appMapping ? Object.keys(appMapping).map((key)=>(0, _apppaths.normalizeAppPath)(key)) : undefined
+    };
+    // Load custom routes
+    const { redirects, headers, rewrites } = await (0, _loadcustomroutes.default)(config);
+    // Compute restricted redirect paths
+    const restrictedRedirectPaths = [
+        '/_next'
+    ].map((pathPrefix)=>config.basePath ? `${config.basePath}${pathPrefix}` : pathPrefix);
+    const isAppPPREnabled = (0, _ppr.checkIsAppPPREnabled)(config.experimental.ppr);
+    // Generate routes manifest
+    const { routesManifest } = (0, _generateroutesmanifest.generateRoutesManifest)({
+        appType,
+        pageKeys,
+        config,
+        redirects,
+        headers,
+        rewrites,
+        restrictedRedirectPaths,
+        isAppPPREnabled
+    });
+    return routesManifest.dynamicRoutes.map((r)=>r.page).concat(routesManifest.staticRoutes.map((r)=>r.page));
+}
+function startServer(dir, port) {
+    const server = _nodehttp.default.createServer((req, res)=>{
+        return (0, _servehandler.default)(req, res, {
+            public: dir
+        });
+    });
+    return new Promise((resolve, reject)=>{
+        function onError(err) {
+            server.close(()=>{
+                reject(err);
+            });
+        }
+        server.on('error', onError);
+        server.listen(port, 'localhost', ()=>{
+            const address = server.address();
+            if (address == null) {
+                reject(Object.defineProperty(new Error('Unable to get server address'), "__NEXT_ERROR_CODE", {
+                    value: "E928",
+                    enumerable: false,
+                    configurable: true
+                }));
+                return;
+            }
+            // No longer needed after startup
+            server.removeListener('error', onError);
+            let addressString;
+            if (typeof address === 'string') {
+                addressString = address;
+            } else if (address.family === 'IPv6' && (address.address === '::' || address.address === '::1')) {
+                addressString = `localhost:${address.port}`;
+            } else if (address.family === 'IPv6') {
+                addressString = `[${address.address}]:${address.port}`;
+            } else {
+                addressString = `${address.address}:${address.port}`;
+            }
+            _log.info(`Bundle analyzer available at http://${addressString}`);
+            resolve();
+        });
+    });
+}
+
+//# sourceMappingURL=index.js.map

qalita/_frontend/node_modules/next/dist/build/define-env.js

@@ -20,11 +20,10 @@ function _interop_require_default(obj) {
 /**
  * Serializes the DefineEnv config so that it can be inserted into the code by Webpack/Turbopack, JSON stringifies each value.
  */ function serializeDefineEnv(defineEnv) {
-    const defineEnvStringified = {};
-    for(const key in defineEnv){
-        const value = defineEnv[key];
-        defineEnvStringified[key] = JSON.stringify(value);
-    }
+    const defineEnvStringified = Object.fromEntries(Object.entries(defineEnv).map(([key, value])=>[
+            key,
+            JSON.stringify(value)
+        ]));
     return defineEnvStringified;
 }
 function getImageConfig(config, dev) {
@@ -49,7 +48,7 @@ function getImageConfig(config, dev) {
     };
 }
 function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir, projectPath, fetchCacheKeyPrefix, hasRewrites, isClient, isEdgeServer, isNodeServer, middlewareMatchers, omitNonDeterministic, rewrites }) {
-    var _config_experimental, _config_experimental_staleTimes, _config_experimental_staleTimes1, _config_experimental_staleTimes2, _config_experimental_staleTimes3, _config_i18n, _config_compiler;
+    var _config_experimental, _config_experimental1, _config_experimental2, _config_experimental_staleTimes, _config_experimental_staleTimes1, _config_experimental_staleTimes2, _config_experimental_staleTimes3, _config_i18n, _config_compiler;
     const nextPublicEnv = (0, _staticenv.getNextPublicEnvironmentVariables)();
     const nextConfigEnv = (0, _staticenv.getNextConfigEnv)(config);
     const isPPREnabled = (0, _ppr.checkIsAppPPREnabled)(config.experimental.ppr);
@@ -83,7 +82,14 @@ function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir,
         'process.env.__NEXT_PPR': isPPREnabled,
         'process.env.__NEXT_CACHE_COMPONENTS': isCacheComponentsEnabled,
         'process.env.__NEXT_USE_CACHE': isUseCacheEnabled,
-        'process.env.NEXT_DEPLOYMENT_ID': ((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.useSkewCookie) ? false : config.deploymentId || false,
+        ...isClient ? {
+            // TODO use `globalThis.NEXT_DEPLOYMENT_ID` on client to still support accessing
+            // process.env.NEXT_DEPLOYMENT_ID in userland
+            'process.env.NEXT_DEPLOYMENT_ID': ((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.useSkewCookie) ? false : config.deploymentId || false
+        } : ((_config_experimental1 = config.experimental) == null ? void 0 : _config_experimental1.runtimeServerDeploymentId) ? {
+        } : {
+            'process.env.NEXT_DEPLOYMENT_ID': ((_config_experimental2 = config.experimental) == null ? void 0 : _config_experimental2.useSkewCookie) ? false : config.deploymentId || false
+        },
         // Propagates the `__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING` environment
         // variable to the client.
         'process.env.__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING': process.env.__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING || false,
@@ -155,7 +161,7 @@ function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir,
         'process.env.__NEXT_MULTI_ZONE_DRAFT_MODE': config.experimental.multiZoneDraftMode ?? false,
         'process.env.__NEXT_TRUST_HOST_HEADER': config.experimental.trustHostHeader ?? false,
         'process.env.__NEXT_ALLOWED_REVALIDATE_HEADERS': config.experimental.allowedRevalidateHeaderKeys ?? [],
-        ...isNodeServer ? {
+        ...isNodeServer || isEdgeServer ? {
             'process.env.__NEXT_RELATIVE_DIST_DIR': config.distDir,
             'process.env.__NEXT_RELATIVE_PROJECT_DIR': _nodepath.default.relative(process.cwd(), projectPath)
         } : {},
@@ -174,7 +180,8 @@ function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir,
         // In the worst case we'll show an option to clear the cache, but it'll be a
         // no-op that just restarts the development server.
         'process.env.__NEXT_BUNDLER_HAS_PERSISTENT_CACHE': !isTurbopack || (config.experimental.turbopackFileSystemCacheForDev ?? false),
-        'process.env.__NEXT_REACT_DEBUG_CHANNEL': config.experimental.reactDebugChannel ?? false
+        'process.env.__NEXT_REACT_DEBUG_CHANNEL': config.experimental.reactDebugChannel ?? false,
+        'process.env.__NEXT_TRANSITION_INDICATOR': config.experimental.transitionIndicator ?? false
     };
     const userDefines = ((_config_compiler = config.compiler) == null ? void 0 : _config_compiler.define) ?? {};
     for(const key in userDefines){
@@ -216,10 +223,12 @@ function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir,
         for(const key in nextConfigEnv){
             serializedDefineEnv[key] = safeKey(key);
         }
-        for (const key of [
-            'process.env.NEXT_DEPLOYMENT_ID'
-        ]){
-            serializedDefineEnv[key] = safeKey(key);
+        if (!config.experimental.runtimeServerDeploymentId) {
+            for (const key of [
+                'process.env.NEXT_DEPLOYMENT_ID'
+            ]){
+                serializedDefineEnv[key] = safeKey(key);
+            }
         }
     }
     return serializedDefineEnv;

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

@@ -282,7 +282,6 @@ function getPageFilePath({ absolutePagePath, pagesDir, appDir, rootDir }) {
 }
 async function createPagesMapping({ isDev, pageExtensions, pagePaths, pagesType, pagesDir, appDir, appDirOnly }) {
     const isAppRoute = pagesType === 'app';
-    const pages = {};
     const promises = pagePaths.map(async (pagePath)=>{
         // Do not process .d.ts files as routes
         if (pagePath.endsWith('.d.ts') && pageExtensions.includes('ts')) {
@@ -311,9 +310,12 @@ async function createPagesMapping({ isDev, pageExtensions, pagePaths, pagesType,
             });
             route = (0, _getmetadataroute.normalizeMetadataPageToRoute)(route, !!(staticInfo.generateImageMetadata || staticInfo.generateSitemaps));
         }
-        pages[route] = normalizedPath;
+        return [
+            route,
+            normalizedPath
+        ];
     });
-    await Promise.all(promises);
+    const pages = Object.fromEntries((await Promise.all(promises)).filter((entry)=>entry != null));
     switch(pagesType){
         case _pagetypes.PAGE_TYPES.ROOT:
             {
@@ -375,7 +377,6 @@ function getEdgeServerEntry(opts) {
             absolutePagePath: opts.absolutePagePath,
             page: opts.page,
             appDirLoader: Buffer.from(opts.appDirLoader || '').toString('base64'),
-            nextConfig: Buffer.from(JSON.stringify(opts.config)).toString('base64'),
             preferredRegion: opts.preferredRegion,
             middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64'),
             cacheHandlers: JSON.stringify(opts.config.cacheHandlers || {})
@@ -423,7 +424,6 @@ function getEdgeServerEntry(opts) {
         dev: opts.isDev,
         isServerComponent: opts.isServerComponent,
         page: opts.page,
-        stringifiedConfig: Buffer.from(JSON.stringify(opts.config)).toString('base64'),
         pagesType: opts.pagesType,
         appDirLoader: Buffer.from(opts.appDirLoader || '').toString('base64'),
         sriEnabled: !opts.isDev && !!((_opts_config_experimental_sri = opts.config.experimental.sri) == null ? void 0 : _opts_config_experimental_sri.algorithm),

qalita/_frontend/node_modules/next/dist/build/generate-routes-manifest.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "generateRoutesManifest", {
+    enumerable: true,
+    get: function() {
+        return generateRoutesManifest;
+    }
+});
+const _approuterheaders = require("../client/components/app-router-headers");
+const _constants = require("../lib/constants");
+const _utils = require("../shared/lib/router/utils");
+const _buildcustomroute = require("../lib/build-custom-route");
+const _utils1 = require("./utils");
+const _sortableroutes = require("../shared/lib/router/utils/sortable-routes");
+function generateRoutesManifest(options) {
+    const { pageKeys, config, redirects, headers, rewrites, restrictedRedirectPaths, isAppPPREnabled, appType } = options;
+    const sortedRoutes = (0, _sortableroutes.sortPages)([
+        ...pageKeys.pages,
+        ...pageKeys.app ?? []
+    ]);
+    const staticRoutes = [];
+    const dynamicRoutes = [];
+    /**
+   * A map of all the pages to their sourcePage value. This is only used for
+   * routes that have PPR enabled and clientSegmentEnabled is true.
+   */ const sourcePages = new Map();
+    for (const route of sortedRoutes){
+        if ((0, _utils.isDynamicRoute)(route)) {
+            dynamicRoutes.push((0, _utils1.pageToRoute)(route, // This property is only relevant when PPR is enabled.
+            undefined));
+        } else if (!(0, _utils1.isReservedPage)(route) || // don't consider /api reserved here
+        route.match(/^\/(api(\/|$))/)) {
+            staticRoutes.push((0, _utils1.pageToRoute)(route));
+        }
+    }
+    const routesManifest = {
+        version: 3,
+        pages404: true,
+        appType,
+        caseSensitive: !!config.experimental.caseSensitiveRoutes,
+        basePath: config.basePath,
+        redirects: redirects.map((r)=>(0, _buildcustomroute.buildCustomRoute)('redirect', r, restrictedRedirectPaths)),
+        headers: headers.map((r)=>(0, _buildcustomroute.buildCustomRoute)('header', r)),
+        rewrites: {
+            beforeFiles: rewrites.beforeFiles.map((r)=>(0, _buildcustomroute.buildCustomRoute)('rewrite', r)),
+            afterFiles: rewrites.afterFiles.map((r)=>(0, _buildcustomroute.buildCustomRoute)('rewrite', r)),
+            fallback: rewrites.fallback.map((r)=>(0, _buildcustomroute.buildCustomRoute)('rewrite', r))
+        },
+        dynamicRoutes,
+        staticRoutes,
+        dataRoutes: [],
+        i18n: config.i18n || undefined,
+        rsc: {
+            header: _approuterheaders.RSC_HEADER,
+            // This vary header is used as a default. It is technically re-assigned in `base-server`,
+            // and may include an additional Vary option for `Next-URL`.
+            varyHeader: `${_approuterheaders.RSC_HEADER}, ${_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER}, ${_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER}, ${_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER}`,
+            prefetchHeader: _approuterheaders.NEXT_ROUTER_PREFETCH_HEADER,
+            didPostponeHeader: _approuterheaders.NEXT_DID_POSTPONE_HEADER,
+            contentTypeHeader: _approuterheaders.RSC_CONTENT_TYPE_HEADER,
+            suffix: _constants.RSC_SUFFIX,
+            prefetchSegmentHeader: _approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,
+            prefetchSegmentSuffix: _constants.RSC_SEGMENT_SUFFIX,
+            prefetchSegmentDirSuffix: _constants.RSC_SEGMENTS_DIR_SUFFIX,
+            clientParamParsing: config.cacheComponents ?? false,
+            clientParamParsingOrigins: config.experimental.clientParamParsingOrigins,
+            dynamicRSCPrerender: isAppPPREnabled && config.cacheComponents === true
+        },
+        rewriteHeaders: {
+            pathHeader: _approuterheaders.NEXT_REWRITTEN_PATH_HEADER,
+            queryHeader: _approuterheaders.NEXT_REWRITTEN_QUERY_HEADER
+        },
+        skipProxyUrlNormalize: config.skipProxyUrlNormalize,
+        ppr: isAppPPREnabled ? {
+            chain: {
+                headers: {
+                    [_constants.NEXT_RESUME_HEADER]: '1'
+                }
+            }
+        } : undefined
+    };
+    return {
+        routesManifest,
+        dynamicRoutes,
+        sourcePages
+    };
+}
+
+//# sourceMappingURL=generate-routes-manifest.js.map