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

qalita/_frontend/node_modules/next/dist/server/request/pathname.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createServerPathnameForMetadata", {
+    enumerable: true,
+    get: function() {
+        return createServerPathnameForMetadata;
+    }
+});
+const _dynamicrendering = require("../app-render/dynamic-rendering");
+const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _dynamicrenderingutils = require("../dynamic-rendering-utils");
+const _invarianterror = require("../../shared/lib/invariant-error");
+function createServerPathnameForMetadata(underlyingPathname, workStore) {
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'prerender':
+            case 'prerender-client':
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+                {
+                    return createPrerenderPathname(underlyingPathname, workStore, workUnitStore);
+                }
+            case 'cache':
+            case 'private-cache':
+            case 'unstable-cache':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createServerPathnameForMetadata should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
+                    value: "E740",
+                    enumerable: false,
+                    configurable: true
+                });
+            case 'prerender-runtime':
+                return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, createRenderPathname(underlyingPathname));
+            case 'request':
+                return createRenderPathname(underlyingPathname);
+            default:
+                workUnitStore;
+        }
+    }
+    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
+}
+function createPrerenderPathname(underlyingPathname, workStore, prerenderStore) {
+    switch(prerenderStore.type){
+        case 'prerender-client':
+            throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderPathname was called inside a client component scope.'), "__NEXT_ERROR_CODE", {
+                value: "E694",
+                enumerable: false,
+                configurable: true
+            });
+        case 'prerender':
+            {
+                const fallbackParams = prerenderStore.fallbackRouteParams;
+                if (fallbackParams && fallbackParams.size > 0) {
+                    return (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`pathname`');
+                }
+                break;
+            }
+        case 'prerender-ppr':
+            {
+                const fallbackParams = prerenderStore.fallbackRouteParams;
+                if (fallbackParams && fallbackParams.size > 0) {
+                    return makeErroringPathname(workStore, prerenderStore.dynamicTracking);
+                }
+                break;
+            }
+        case 'prerender-legacy':
+            break;
+        default:
+            prerenderStore;
+    }
+    // We don't have any fallback params so we have an entirely static safe params object
+    return Promise.resolve(underlyingPathname);
+}
+function makeErroringPathname(workStore, dynamicTracking) {
+    let reject = null;
+    const promise = new Promise((_, re)=>{
+        reject = re;
+    });
+    const originalThen = promise.then.bind(promise);
+    // We instrument .then so that we can generate a tracking event only if you actually
+    // await this promise, not just that it is created.
+    promise.then = (onfulfilled, onrejected)=>{
+        if (reject) {
+            try {
+                (0, _dynamicrendering.postponeWithTracking)(workStore.route, 'metadata relative url resolving', dynamicTracking);
+            } catch (error) {
+                reject(error);
+                reject = null;
+            }
+        }
+        return originalThen(onfulfilled, onrejected);
+    };
+    // We wrap in a noop proxy to trick the runtime into thinking it
+    // isn't a native promise (it's not really). This is so that awaiting
+    // the promise will call the `then` property triggering the lazy postpone
+    return new Proxy(promise, {});
+}
+function createRenderPathname(underlyingPathname) {
+    return Promise.resolve(underlyingPathname);
+}
+
+//# sourceMappingURL=pathname.js.map

qalita/_frontend/node_modules/next/dist/server/request/root-params.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getRootParam", {
+    enumerable: true,
+    get: function() {
+        return getRootParam;
+    }
+});
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _dynamicrendering = require("../app-render/dynamic-rendering");
+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 _reflectutils = require("../../shared/lib/utils/reflect-utils");
+const _actionasyncstorageexternal = require("../app-render/action-async-storage.external");
+function getRootParam(paramName) {
+    const apiName = `\`import('next/root-params').${paramName}()\``;
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw Object.defineProperty(new _invarianterror.InvariantError(`Missing workStore in ${apiName}`), "__NEXT_ERROR_CODE", {
+            value: "E764",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (!workUnitStore) {
+        throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} outside of a Server Component. This is not allowed.`), "__NEXT_ERROR_CODE", {
+            value: "E774",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const actionStore = _actionasyncstorageexternal.actionAsyncStorage.getStore();
+    if (actionStore) {
+        if (actionStore.isAppRoute) {
+            // TODO(root-params): add support for route handlers
+            throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} inside a Route Handler. Support for this API in Route Handlers is planned for a future version of Next.js.`), "__NEXT_ERROR_CODE", {
+                value: "E765",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (actionStore.isAction && workUnitStore.phase === 'action') {
+            // Actions are not fundamentally tied to a route (even if they're always submitted from some page),
+            // so root params would be inconsistent if an action is called from multiple roots.
+            // Make sure we check if the phase is "action" - we should not error in the rerender
+            // after an action revalidates or updates cookies (which will still have `actionStore.isAction === true`)
+            throw Object.defineProperty(new Error(`${apiName} was used inside a Server Action. This is not supported. Functions from 'next/root-params' can only be called in the context of a route.`), "__NEXT_ERROR_CODE", {
+                value: "E766",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    switch(workUnitStore.type){
+        case 'unstable-cache':
+        case 'cache':
+            {
+                throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} inside \`"use cache"\` or \`unstable_cache\`. Support for this API inside cache scopes is planned for a future version of Next.js.`), "__NEXT_ERROR_CODE", {
+                    value: "E760",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        case 'prerender':
+        case 'prerender-client':
+        case 'prerender-ppr':
+        case 'prerender-legacy':
+            {
+                return createPrerenderRootParamPromise(paramName, workStore, workUnitStore, apiName);
+            }
+        case 'private-cache':
+        case 'prerender-runtime':
+        case 'request':
+            {
+                break;
+            }
+        default:
+            {
+                workUnitStore;
+            }
+    }
+    return Promise.resolve(workUnitStore.rootParams[paramName]);
+}
+function createPrerenderRootParamPromise(paramName, workStore, prerenderStore, apiName) {
+    switch(prerenderStore.type){
+        case 'prerender-client':
+            {
+                throw Object.defineProperty(new _invarianterror.InvariantError(`${apiName} must not be used within a client component. Next.js should be preventing ${apiName} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                    value: "E693",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        case 'prerender':
+        case 'prerender-legacy':
+        case 'prerender-ppr':
+        default:
+    }
+    const underlyingParams = prerenderStore.rootParams;
+    switch(prerenderStore.type){
+        case 'prerender':
+            {
+                // We are in a cacheComponents prerender.
+                // The param is a fallback, so it should be treated as dynamic.
+                if (prerenderStore.fallbackRouteParams && prerenderStore.fallbackRouteParams.has(paramName)) {
+                    return (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, apiName);
+                }
+                break;
+            }
+        case 'prerender-ppr':
+            {
+                // We aren't in a cacheComponents prerender, but the param is a fallback,
+                // so we need to make an erroring params object which will postpone/error if you access it
+                if (prerenderStore.fallbackRouteParams && prerenderStore.fallbackRouteParams.has(paramName)) {
+                    return makeErroringRootParamPromise(paramName, workStore, prerenderStore, apiName);
+                }
+                break;
+            }
+        case 'prerender-legacy':
+            {
+                break;
+            }
+        default:
+            {
+                prerenderStore;
+            }
+    }
+    // If the param is not a fallback param, we just return the statically available value.
+    return Promise.resolve(underlyingParams[paramName]);
+}
+/** Deliberately async -- we want to create a rejected promise, not error synchronously. */ async function makeErroringRootParamPromise(paramName, workStore, prerenderStore, apiName) {
+    const expression = (0, _reflectutils.describeStringPropertyAccess)(apiName, paramName);
+    // In most dynamic APIs, we also throw if `dynamic = "error"`.
+    // However, root params are only dynamic when we're generating a fallback shell,
+    // and even with `dynamic = "error"` we still support generating dynamic fallback shells.
+    // TODO: remove this comment when cacheComponents is the default since there will be no `dynamic = "error"`
+    switch(prerenderStore.type){
+        case 'prerender-ppr':
+            {
+                return (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
+            }
+        case 'prerender-legacy':
+            {
+                return (0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
+            }
+        default:
+            {
+                prerenderStore;
+            }
+    }
+}
+
+//# sourceMappingURL=root-params.js.map