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

qalita/_frontend/node_modules/next/dist/server/stream-utils/uint8array-helpers.js

@@ -0,0 +1,69 @@
+/**
+ * Find the starting index of Uint8Array `b` within Uint8Array `a`.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    indexOfUint8Array: null,
+    isEquivalentUint8Arrays: null,
+    removeFromUint8Array: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    indexOfUint8Array: function() {
+        return indexOfUint8Array;
+    },
+    isEquivalentUint8Arrays: function() {
+        return isEquivalentUint8Arrays;
+    },
+    removeFromUint8Array: function() {
+        return removeFromUint8Array;
+    }
+});
+function indexOfUint8Array(a, b) {
+    if (b.length === 0) return 0;
+    if (a.length === 0 || b.length > a.length) return -1;
+    // start iterating through `a`
+    for(let i = 0; i <= a.length - b.length; i++){
+        let completeMatch = true;
+        // from index `i`, iterate through `b` and check for mismatch
+        for(let j = 0; j < b.length; j++){
+            // if the values do not match, then this isn't a complete match, exit `b` iteration early and iterate to next index of `a`.
+            if (a[i + j] !== b[j]) {
+                completeMatch = false;
+                break;
+            }
+        }
+        if (completeMatch) {
+            return i;
+        }
+    }
+    return -1;
+}
+function isEquivalentUint8Arrays(a, b) {
+    if (a.length !== b.length) return false;
+    for(let i = 0; i < a.length; i++){
+        if (a[i] !== b[i]) return false;
+    }
+    return true;
+}
+function removeFromUint8Array(a, b) {
+    const tagIndex = indexOfUint8Array(a, b);
+    if (tagIndex === 0) return a.subarray(b.length);
+    if (tagIndex > -1) {
+        const removed = new Uint8Array(a.length - b.length);
+        removed.set(a.slice(0, tagIndex));
+        removed.set(a.slice(tagIndex + b.length), tagIndex);
+        return removed;
+    } else {
+        return a;
+    }
+}
+
+//# sourceMappingURL=uint8array-helpers.js.map

qalita/_frontend/node_modules/next/dist/server/typescript/constant.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ALLOWED_EXPORTS: null,
+    ALLOWED_LAYOUT_PROPS: null,
+    ALLOWED_PAGE_PROPS: null,
+    DISALLOWED_SERVER_REACT_APIS: null,
+    DISALLOWED_SERVER_REACT_DOM_APIS: null,
+    LEGACY_CONFIG_EXPORT: null,
+    NEXT_TS_ERRORS: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ALLOWED_EXPORTS: function() {
+        return ALLOWED_EXPORTS;
+    },
+    ALLOWED_LAYOUT_PROPS: function() {
+        return ALLOWED_LAYOUT_PROPS;
+    },
+    ALLOWED_PAGE_PROPS: function() {
+        return ALLOWED_PAGE_PROPS;
+    },
+    DISALLOWED_SERVER_REACT_APIS: function() {
+        return DISALLOWED_SERVER_REACT_APIS;
+    },
+    DISALLOWED_SERVER_REACT_DOM_APIS: function() {
+        return DISALLOWED_SERVER_REACT_DOM_APIS;
+    },
+    LEGACY_CONFIG_EXPORT: function() {
+        return LEGACY_CONFIG_EXPORT;
+    },
+    NEXT_TS_ERRORS: function() {
+        return NEXT_TS_ERRORS;
+    }
+});
+const NEXT_TS_ERRORS = {
+    INVALID_SERVER_API: 71001,
+    INVALID_ENTRY_EXPORT: 71002,
+    INVALID_OPTION_VALUE: 71003,
+    MISPLACED_ENTRY_DIRECTIVE: 71004,
+    INVALID_PAGE_PROP: 71005,
+    INVALID_CONFIG_OPTION: 71006,
+    INVALID_CLIENT_ENTRY_PROP: 71007,
+    INVALID_METADATA_EXPORT: 71008,
+    INVALID_ERROR_COMPONENT: 71009,
+    INVALID_ENTRY_DIRECTIVE: 71010,
+    INVALID_SERVER_ENTRY_RETURN: 71011
+};
+const ALLOWED_EXPORTS = [
+    'config',
+    'generateStaticParams',
+    'metadata',
+    'generateMetadata',
+    'viewport',
+    'generateViewport'
+];
+const LEGACY_CONFIG_EXPORT = 'config';
+const DISALLOWED_SERVER_REACT_APIS = [
+    'useState',
+    'useEffect',
+    'useLayoutEffect',
+    'useDeferredValue',
+    'useImperativeHandle',
+    'useInsertionEffect',
+    'useReducer',
+    'useRef',
+    'useSyncExternalStore',
+    'useTransition',
+    'Component',
+    'PureComponent',
+    'createContext',
+    'createFactory',
+    'experimental_useOptimistic',
+    'useOptimistic',
+    'useActionState'
+];
+const DISALLOWED_SERVER_REACT_DOM_APIS = [
+    'useFormStatus',
+    'useFormState'
+];
+const ALLOWED_PAGE_PROPS = [
+    'params',
+    'searchParams'
+];
+const ALLOWED_LAYOUT_PROPS = [
+    'params',
+    'children'
+];
+
+//# sourceMappingURL=constant.js.map

qalita/_frontend/node_modules/next/dist/server/typescript/index.js

@@ -0,0 +1,199 @@
+/**
+ * This is a TypeScript language service plugin for Next.js app directory,
+ * it provides the following features:
+ *
+ * - Warns about disallowed React APIs in server components.
+ * - Warns about disallowed layout and page exports.
+ * - Autocompletion for entry configurations.
+ * - Hover hint and docs for entry configurations.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createTSPlugin", {
+    enumerable: true,
+    get: function() {
+        return createTSPlugin;
+    }
+});
+const _utils = require("./utils");
+const _constant = require("./constant");
+const _config = /*#__PURE__*/ _interop_require_default(require("./rules/config"));
+const _server = /*#__PURE__*/ _interop_require_default(require("./rules/server"));
+const _entry = /*#__PURE__*/ _interop_require_default(require("./rules/entry"));
+const _clientboundary = /*#__PURE__*/ _interop_require_default(require("./rules/client-boundary"));
+const _serverboundary = /*#__PURE__*/ _interop_require_default(require("./rules/server-boundary"));
+const _metadata = /*#__PURE__*/ _interop_require_default(require("./rules/metadata"));
+const _error = /*#__PURE__*/ _interop_require_default(require("./rules/error"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const createTSPlugin = ({ typescript: ts })=>{
+    function create(info) {
+        // Get plugin options
+        // config is the plugin options from the user's tsconfig.json
+        // e.g. { "plugins": [{ "name": "next", "enabled": true }] }
+        // config will be { "name": "next", "enabled": true }
+        // The default user config is { "name": "next" }
+        const isPluginEnabled = info.config.enabled ?? true;
+        if (!isPluginEnabled) {
+            return info.languageService;
+        }
+        (0, _utils.init)({
+            ts,
+            info
+        });
+        // Set up decorator object
+        const proxy = Object.create(null);
+        for (let k of Object.keys(info.languageService)){
+            const x = info.languageService[k];
+            // @ts-expect-error - JS runtime trickery which is tricky to type tersely
+            proxy[k] = (...args)=>x.apply(info.languageService, args);
+        }
+        // Auto completion
+        proxy.getCompletionsAtPosition = (fileName, position, options)=>{
+            let prior = info.languageService.getCompletionsAtPosition(fileName, position, options) || {
+                isGlobalCompletion: false,
+                isMemberCompletion: false,
+                isNewIdentifierLocation: false,
+                entries: []
+            };
+            if (!(0, _utils.isAppEntryFile)(fileName)) return prior;
+            // If it's a server entry.
+            const entryInfo = (0, _utils.getEntryInfo)(fileName);
+            if (!entryInfo.client) {
+                // Remove specified entries from completion list
+                prior.entries = _server.default.filterCompletionsAtPosition(prior.entries);
+            }
+            // Add auto completions for export configs.
+            _config.default.addCompletionsAtPosition(fileName, position, prior);
+            const source = (0, _utils.getSource)(fileName);
+            if (!source) return prior;
+            ts.forEachChild(source, (node)=>{
+                // Auto completion for default export function's props.
+                if ((0, _utils.isPositionInsideNode)(position, node) && (0, _utils.isDefaultFunctionExport)(node)) {
+                    prior.entries.push(..._entry.default.getCompletionsAtPosition(fileName, node, position));
+                }
+            });
+            return prior;
+        };
+        // Show auto completion details
+        proxy.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, data)=>{
+            const entryCompletionEntryDetails = _config.default.getCompletionEntryDetails(entryName, data, fileName);
+            if (entryCompletionEntryDetails) return entryCompletionEntryDetails;
+            return info.languageService.getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences, data);
+        };
+        // Quick info
+        proxy.getQuickInfoAtPosition = (fileName, position)=>{
+            const prior = info.languageService.getQuickInfoAtPosition(fileName, position);
+            if (!(0, _utils.isAppEntryFile)(fileName)) return prior;
+            // Remove type suggestions for disallowed APIs in server components.
+            const entryInfo = (0, _utils.getEntryInfo)(fileName);
+            if (!entryInfo.client) {
+                const definitions = info.languageService.getDefinitionAtPosition(fileName, position);
+                if (definitions && _server.default.hasDisallowedReactAPIDefinition(definitions)) {
+                    return;
+                }
+            }
+            const overridden = _config.default.getQuickInfoAtPosition(fileName, position);
+            if (overridden) return overridden;
+            return prior;
+        };
+        // Show errors for disallowed imports
+        proxy.getSemanticDiagnostics = (fileName)=>{
+            const prior = info.languageService.getSemanticDiagnostics(fileName);
+            const source = (0, _utils.getSource)(fileName);
+            if (!source) return prior;
+            let isClientEntry = false;
+            let isServerEntry = false;
+            const isAppEntry = (0, _utils.isAppEntryFile)(fileName);
+            try {
+                const entryInfo = (0, _utils.getEntryInfo)(fileName, true);
+                isClientEntry = entryInfo.client;
+                isServerEntry = entryInfo.server;
+            } catch (e) {
+                prior.push({
+                    file: source,
+                    category: ts.DiagnosticCategory.Error,
+                    code: _constant.NEXT_TS_ERRORS.MISPLACED_ENTRY_DIRECTIVE,
+                    ...e
+                });
+                isClientEntry = false;
+                isServerEntry = false;
+            }
+            if ((0, _utils.isInsideApp)(fileName)) {
+                const errorDiagnostic = _error.default.getSemanticDiagnostics(source, isClientEntry);
+                prior.push(...errorDiagnostic);
+            }
+            ts.forEachChild(source, (node)=>{
+                var _node_modifiers, _node_modifiers1;
+                if (ts.isImportDeclaration(node)) {
+                    // import ...
+                    if (isAppEntry) {
+                        if (!isClientEntry || isServerEntry) {
+                            // Check if it has valid imports in the server layer
+                            const diagnostics = _server.default.getSemanticDiagnosticsForImportDeclaration(source, node);
+                            prior.push(...diagnostics);
+                        }
+                    }
+                } else if (ts.isVariableStatement(node) && ((_node_modifiers = node.modifiers) == null ? void 0 : _node_modifiers.some((m)=>m.kind === ts.SyntaxKind.ExportKeyword))) {
+                    // export const ...
+                    if (isAppEntry) {
+                        // Check if it has correct option exports
+                        const diagnostics = _config.default.getSemanticDiagnosticsForExportVariableStatement(source, node);
+                        const metadataDiagnostics = isClientEntry ? _metadata.default.client.getSemanticDiagnosticsForExportVariableStatement(fileName, node) : _metadata.default.server.getSemanticDiagnosticsForExportVariableStatement(fileName, node);
+                        prior.push(...diagnostics, ...metadataDiagnostics);
+                    }
+                    if (isClientEntry) {
+                        prior.push(..._clientboundary.default.getSemanticDiagnosticsForExportVariableStatement(source, node));
+                    }
+                    if (isServerEntry) {
+                        prior.push(..._serverboundary.default.getSemanticDiagnosticsForExportVariableStatement(source, node));
+                    }
+                } else if ((0, _utils.isDefaultFunctionExport)(node)) {
+                    // export default function ...
+                    if (isAppEntry) {
+                        const diagnostics = _entry.default.getSemanticDiagnostics(fileName, source, node);
+                        prior.push(...diagnostics);
+                    }
+                    if (isClientEntry) {
+                        prior.push(..._clientboundary.default.getSemanticDiagnosticsForFunctionExport(source, node));
+                    }
+                    if (isServerEntry) {
+                        prior.push(..._serverboundary.default.getSemanticDiagnosticsForFunctionExport(source, node));
+                    }
+                } else if (ts.isFunctionDeclaration(node) && ((_node_modifiers1 = node.modifiers) == null ? void 0 : _node_modifiers1.some((m)=>m.kind === ts.SyntaxKind.ExportKeyword))) {
+                    // export function ...
+                    if (isAppEntry) {
+                        const metadataDiagnostics = isClientEntry ? _metadata.default.client.getSemanticDiagnosticsForExportVariableStatement(fileName, node) : _metadata.default.server.getSemanticDiagnosticsForExportVariableStatement(fileName, node);
+                        prior.push(...metadataDiagnostics);
+                    }
+                    if (isClientEntry) {
+                        prior.push(..._clientboundary.default.getSemanticDiagnosticsForFunctionExport(source, node));
+                    }
+                    if (isServerEntry) {
+                        prior.push(..._serverboundary.default.getSemanticDiagnosticsForFunctionExport(source, node));
+                    }
+                } else if (ts.isExportDeclaration(node)) {
+                    // export { ... }
+                    if (isAppEntry) {
+                        const metadataDiagnostics = isClientEntry ? _metadata.default.client.getSemanticDiagnosticsForExportDeclaration(fileName, node) : _metadata.default.server.getSemanticDiagnosticsForExportDeclaration(fileName, node);
+                        prior.push(...metadataDiagnostics);
+                    }
+                    if (isServerEntry) {
+                        prior.push(..._serverboundary.default.getSemanticDiagnosticsForExportDeclaration(source, node));
+                    }
+                }
+            });
+            return prior;
+        };
+        return proxy;
+    }
+    return {
+        create
+    };
+};
+
+//# sourceMappingURL=index.js.map

qalita/_frontend/node_modules/next/dist/server/typescript/rules/client-boundary.js

@@ -0,0 +1,97 @@
+// This module provides intellisense for all components that has the `"use client"` directive.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _constant = require("../constant");
+const _utils = require("../utils");
+const clientBoundary = {
+    getSemanticDiagnosticsForExportVariableStatement (source, node) {
+        const ts = (0, _utils.getTs)();
+        const diagnostics = [];
+        if (ts.isVariableDeclarationList(node.declarationList)) {
+            for (const declaration of node.declarationList.declarations){
+                const initializer = declaration.initializer;
+                if (initializer && ts.isArrowFunction(initializer)) {
+                    diagnostics.push(...clientBoundary.getSemanticDiagnosticsForFunctionExport(source, initializer));
+                }
+            }
+        }
+        return diagnostics;
+    },
+    getSemanticDiagnosticsForFunctionExport (source, node) {
+        var _node_parameters;
+        const ts = (0, _utils.getTs)();
+        const typeChecker = (0, _utils.getTypeChecker)();
+        if (!typeChecker) return [];
+        const diagnostics = [];
+        const isErrorFile = /[\\/]error\.tsx?$/.test(source.fileName);
+        const isGlobalErrorFile = /[\\/]global-error\.tsx?$/.test(source.fileName);
+        const props = (_node_parameters = node.parameters) == null ? void 0 : _node_parameters[0];
+        if (props) {
+            var _propsType_symbol_getDeclarations, _propsType_symbol;
+            const propsType = typeChecker.getTypeAtLocation(props);
+            const typeNode = (_propsType_symbol = propsType.symbol) == null ? void 0 : (_propsType_symbol_getDeclarations = _propsType_symbol.getDeclarations()) == null ? void 0 : _propsType_symbol_getDeclarations[0];
+            if (typeNode && ts.isTypeLiteralNode(typeNode)) {
+                for (const member of typeNode.members){
+                    if (ts.isPropertySignature(member)) {
+                        const propName = member.name.getText();
+                        const propType = member.type;
+                        if (propType) {
+                            var _propTypeInfo_symbol_getDeclarations, _propTypeInfo_symbol;
+                            const propTypeInfo = typeChecker.getTypeAtLocation(propType);
+                            const typeDeclarationNode = (_propTypeInfo_symbol = propTypeInfo.symbol) == null ? void 0 : (_propTypeInfo_symbol_getDeclarations = _propTypeInfo_symbol.getDeclarations()) == null ? void 0 : _propTypeInfo_symbol_getDeclarations[0];
+                            if (typeDeclarationNode) {
+                                if (ts.isFunctionTypeNode(typeDeclarationNode) || // someFunc(): void
+                                ts.isMethodSignature(typeDeclarationNode)) {
+                                    // By convention, props named "action" can accept functions since we
+                                    // assume these are Server Actions. Structurally, there's no
+                                    // difference between a Server Action and a normal function until
+                                    // TypeScript exposes directives in the type of a function. This
+                                    // will miss accidentally passing normal functions but a false
+                                    // negative is better than a false positive given how frequent the
+                                    // false-positive would be.
+                                    const maybeServerAction = propName === 'action' || /.+Action$/.test(propName);
+                                    // There's a special case for the error file that the `reset` prop
+                                    // is allowed to be a function:
+                                    // https://github.com/vercel/next.js/issues/46573
+                                    const isErrorReset = (isErrorFile || isGlobalErrorFile) && propName === 'reset';
+                                    if (!maybeServerAction && !isErrorReset) {
+                                        diagnostics.push({
+                                            file: source,
+                                            category: ts.DiagnosticCategory.Warning,
+                                            code: _constant.NEXT_TS_ERRORS.INVALID_CLIENT_ENTRY_PROP,
+                                            messageText: `Props must be serializable for components in the "use client" entry file. ` + `"${propName}" is a function that's not a Server Action. ` + `Rename "${propName}" either to "action" or have its name end with "Action" e.g. "${propName}Action" to indicate it is a Server Action.`,
+                                            start: propType.getStart(),
+                                            length: propType.getWidth()
+                                        });
+                                    }
+                                } else if (// Show warning for not serializable props.
+                                ts.isConstructorTypeNode(typeDeclarationNode) || ts.isClassDeclaration(typeDeclarationNode)) {
+                                    diagnostics.push({
+                                        file: source,
+                                        category: ts.DiagnosticCategory.Warning,
+                                        code: _constant.NEXT_TS_ERRORS.INVALID_CLIENT_ENTRY_PROP,
+                                        messageText: `Props must be serializable for components in the "use client" entry file, "${propName}" is invalid.`,
+                                        start: propType.getStart(),
+                                        length: propType.getWidth()
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return diagnostics;
+    }
+};
+const _default = clientBoundary;
+
+//# sourceMappingURL=client-boundary.js.map