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

qalita/_frontend/node_modules/next/dist/server/app-render/action-utils.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createServerModuleMap: null,
+    selectWorkerForForwarding: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createServerModuleMap: function() {
+        return createServerModuleMap;
+    },
+    selectWorkerForForwarding: function() {
+        return selectWorkerForForwarding;
+    }
+});
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _pathhasprefix = require("../../shared/lib/router/utils/path-has-prefix");
+const _removepathprefix = require("../../shared/lib/router/utils/remove-path-prefix");
+const _workasyncstorageexternal = require("./work-async-storage.external");
+function createServerModuleMap({ serverActionsManifest }) {
+    return new Proxy({}, {
+        get: (_, id)=>{
+            var _serverActionsManifest__id, _serverActionsManifest_;
+            const workers = (_serverActionsManifest_ = serverActionsManifest[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node']) == null ? void 0 : (_serverActionsManifest__id = _serverActionsManifest_[id]) == null ? void 0 : _serverActionsManifest__id.workers;
+            if (!workers) {
+                return undefined;
+            }
+            const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+            let workerEntry;
+            if (workStore) {
+                workerEntry = workers[normalizeWorkerPageName(workStore.page)];
+            } else {
+                // If there's no work store defined, we can assume that a server
+                // module map is needed during module evaluation, e.g. to create a
+                // server action using a higher-order function. Therefore it should be
+                // safe to return any entry from the manifest that matches the action
+                // ID. They all refer to the same module ID, which must also exist in
+                // the current page bundle. TODO: This is currently not guaranteed in
+                // Turbopack, and needs to be fixed.
+                workerEntry = Object.values(workers).at(0);
+            }
+            if (!workerEntry) {
+                return undefined;
+            }
+            const { moduleId, async } = workerEntry;
+            return {
+                id: moduleId,
+                name: id,
+                chunks: [],
+                async
+            };
+        }
+    });
+}
+function selectWorkerForForwarding(actionId, pageName, serverActionsManifest) {
+    var _serverActionsManifest__actionId;
+    const workers = (_serverActionsManifest__actionId = serverActionsManifest[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node'][actionId]) == null ? void 0 : _serverActionsManifest__actionId.workers;
+    const workerName = normalizeWorkerPageName(pageName);
+    // no workers, nothing to forward to
+    if (!workers) return;
+    // if there is a worker for this page, no need to forward it.
+    if (workers[workerName]) {
+        return;
+    }
+    // otherwise, grab the first worker that has a handler for this action id
+    return denormalizeWorkerPageName(Object.keys(workers)[0]);
+}
+/**
+ * The flight entry loader keys actions by bundlePath.
+ * bundlePath corresponds with the relative path (including 'app') to the page entrypoint.
+ */ function normalizeWorkerPageName(pageName) {
+    if ((0, _pathhasprefix.pathHasPrefix)(pageName, 'app')) {
+        return pageName;
+    }
+    return 'app' + pageName;
+}
+/**
+ * Converts a bundlePath (relative path to the entrypoint) to a routable page name
+ */ function denormalizeWorkerPageName(bundlePath) {
+    return (0, _apppaths.normalizeAppPath)((0, _removepathprefix.removePathPrefix)(bundlePath, 'app'));
+}
+
+//# sourceMappingURL=action-utils.js.map

qalita/_frontend/node_modules/next/dist/server/app-render/after-task-async-storage-instance.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "afterTaskAsyncStorageInstance", {
+    enumerable: true,
+    get: function() {
+        return afterTaskAsyncStorageInstance;
+    }
+});
+const _asynclocalstorage = require("./async-local-storage");
+const afterTaskAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
+
+//# sourceMappingURL=after-task-async-storage-instance.js.map

qalita/_frontend/node_modules/next/dist/server/app-render/after-task-async-storage.external.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "afterTaskAsyncStorage", {
+    enumerable: true,
+    get: function() {
+        return _aftertaskasyncstorageinstance.afterTaskAsyncStorageInstance;
+    }
+});
+const _aftertaskasyncstorageinstance = require("./after-task-async-storage-instance");
+
+//# sourceMappingURL=after-task-async-storage.external.js.map

qalita/_frontend/node_modules/next/dist/server/app-render/app-render-prerender-utils.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ReactServerPrerenderResult: null,
+    ReactServerResult: null,
+    createReactServerPrerenderResult: null,
+    createReactServerPrerenderResultFromRender: null,
+    prerenderAndAbortInSequentialTasks: null,
+    prerenderAndAbortInSequentialTasksWithStages: null,
+    processPrelude: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ReactServerPrerenderResult: function() {
+        return ReactServerPrerenderResult;
+    },
+    ReactServerResult: function() {
+        return ReactServerResult;
+    },
+    createReactServerPrerenderResult: function() {
+        return createReactServerPrerenderResult;
+    },
+    createReactServerPrerenderResultFromRender: function() {
+        return createReactServerPrerenderResultFromRender;
+    },
+    prerenderAndAbortInSequentialTasks: function() {
+        return prerenderAndAbortInSequentialTasks;
+    },
+    prerenderAndAbortInSequentialTasksWithStages: function() {
+        return prerenderAndAbortInSequentialTasksWithStages;
+    },
+    processPrelude: function() {
+        return processPrelude;
+    }
+});
+const _invarianterror = require("../../shared/lib/invariant-error");
+function prerenderAndAbortInSequentialTasks(prerender, abort) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new _invarianterror.InvariantError('`prerenderAndAbortInSequentialTasks` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
+            value: "E538",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        return new Promise((resolve, reject)=>{
+            let pendingResult;
+            setTimeout(()=>{
+                try {
+                    pendingResult = prerender();
+                    pendingResult.catch(()=>{});
+                } catch (err) {
+                    reject(err);
+                }
+            }, 0);
+            setTimeout(()=>{
+                abort();
+                resolve(pendingResult);
+            }, 0);
+        });
+    }
+}
+function prerenderAndAbortInSequentialTasksWithStages(prerender, advanceStage, abort) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new _invarianterror.InvariantError('`prerenderAndAbortInSequentialTasksWithStages` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
+            value: "E778",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        return new Promise((resolve, reject)=>{
+            let pendingResult;
+            setTimeout(()=>{
+                try {
+                    pendingResult = prerender();
+                    pendingResult.catch(()=>{});
+                } catch (err) {
+                    reject(err);
+                }
+            }, 0);
+            setTimeout(()=>{
+                advanceStage();
+            }, 0);
+            setTimeout(()=>{
+                abort();
+                resolve(pendingResult);
+            }, 0);
+        });
+    }
+}
+class ReactServerResult {
+    constructor(stream){
+        this._stream = stream;
+    }
+    tee() {
+        if (this._stream === null) {
+            throw Object.defineProperty(new Error('Cannot tee a ReactServerResult that has already been consumed'), "__NEXT_ERROR_CODE", {
+                value: "E106",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const tee = this._stream.tee();
+        this._stream = tee[0];
+        return tee[1];
+    }
+    consume() {
+        if (this._stream === null) {
+            throw Object.defineProperty(new Error('Cannot consume a ReactServerResult that has already been consumed'), "__NEXT_ERROR_CODE", {
+                value: "E470",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const stream = this._stream;
+        this._stream = null;
+        return stream;
+    }
+}
+async function createReactServerPrerenderResult(underlying) {
+    const chunks = [];
+    const { prelude } = await underlying;
+    const reader = prelude.getReader();
+    while(true){
+        const { done, value } = await reader.read();
+        if (done) {
+            return new ReactServerPrerenderResult(chunks);
+        } else {
+            chunks.push(value);
+        }
+    }
+}
+async function createReactServerPrerenderResultFromRender(underlying) {
+    const chunks = [];
+    const reader = underlying.getReader();
+    while(true){
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        } else {
+            chunks.push(value);
+        }
+    }
+    return new ReactServerPrerenderResult(chunks);
+}
+class ReactServerPrerenderResult {
+    assertChunks(expression) {
+        if (this._chunks === null) {
+            throw Object.defineProperty(new _invarianterror.InvariantError(`Cannot \`${expression}\` on a ReactServerPrerenderResult that has already been consumed.`), "__NEXT_ERROR_CODE", {
+                value: "E593",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        return this._chunks;
+    }
+    consumeChunks(expression) {
+        const chunks = this.assertChunks(expression);
+        this.consume();
+        return chunks;
+    }
+    consume() {
+        this._chunks = null;
+    }
+    constructor(chunks){
+        this._chunks = chunks;
+    }
+    asUnclosingStream() {
+        const chunks = this.assertChunks('asUnclosingStream()');
+        return createUnclosingStream(chunks);
+    }
+    consumeAsUnclosingStream() {
+        const chunks = this.consumeChunks('consumeAsUnclosingStream()');
+        return createUnclosingStream(chunks);
+    }
+    asStream() {
+        const chunks = this.assertChunks('asStream()');
+        return createClosingStream(chunks);
+    }
+    consumeAsStream() {
+        const chunks = this.consumeChunks('consumeAsStream()');
+        return createClosingStream(chunks);
+    }
+}
+function createUnclosingStream(chunks) {
+    let i = 0;
+    return new ReadableStream({
+        async pull (controller) {
+            if (i < chunks.length) {
+                controller.enqueue(chunks[i++]);
+            }
+        // we intentionally keep the stream open. The consumer will clear
+        // out chunks once finished and the remaining memory will be GC'd
+        // when this object goes out of scope
+        }
+    });
+}
+function createClosingStream(chunks) {
+    let i = 0;
+    return new ReadableStream({
+        async pull (controller) {
+            if (i < chunks.length) {
+                controller.enqueue(chunks[i++]);
+            } else {
+                controller.close();
+            }
+        }
+    });
+}
+async function processPrelude(unprocessedPrelude) {
+    const [prelude, peek] = unprocessedPrelude.tee();
+    const reader = peek.getReader();
+    const firstResult = await reader.read();
+    reader.cancel();
+    const preludeIsEmpty = firstResult.done === true;
+    return {
+        prelude,
+        preludeIsEmpty
+    };
+}
+
+//# sourceMappingURL=app-render-prerender-utils.js.map

qalita/_frontend/node_modules/next/dist/server/app-render/app-render-render-utils.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    pipelineInSequentialTasks: null,
+    scheduleInSequentialTasks: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    pipelineInSequentialTasks: function() {
+        return pipelineInSequentialTasks;
+    },
+    scheduleInSequentialTasks: function() {
+        return scheduleInSequentialTasks;
+    }
+});
+const _invarianterror = require("../../shared/lib/invariant-error");
+function scheduleInSequentialTasks(render, followup) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new _invarianterror.InvariantError('`scheduleInSequentialTasks` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
+            value: "E591",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        return new Promise((resolve, reject)=>{
+            let pendingResult;
+            setTimeout(()=>{
+                try {
+                    pendingResult = render();
+                } catch (err) {
+                    reject(err);
+                }
+            }, 0);
+            setTimeout(()=>{
+                followup();
+                resolve(pendingResult);
+            }, 0);
+        });
+    }
+}
+function pipelineInSequentialTasks(one, two, three) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new _invarianterror.InvariantError('`pipelineInSequentialTasks` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
+            value: "E875",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        return new Promise((resolve, reject)=>{
+            let oneResult = undefined;
+            setTimeout(()=>{
+                try {
+                    oneResult = one();
+                } catch (err) {
+                    clearTimeout(twoId);
+                    clearTimeout(threeId);
+                    reject(err);
+                }
+            }, 0);
+            let twoResult = undefined;
+            const twoId = setTimeout(()=>{
+                // if `one` threw, then this timeout would've been cleared,
+                // so if we got here, we're guaranteed to have a value.
+                try {
+                    twoResult = two(oneResult);
+                } catch (err) {
+                    clearTimeout(threeId);
+                    reject(err);
+                }
+            }, 0);
+            const threeId = setTimeout(()=>{
+                // if `two` threw, then this timeout would've been cleared,
+                // so if we got here, we're guaranteed to have a value.
+                try {
+                    resolve(three(twoResult));
+                } catch (err) {
+                    reject(err);
+                }
+            }, 0);
+        });
+    }
+}
+
+//# sourceMappingURL=app-render-render-utils.js.map