repoburg 1.1.0 → 1.1.1

package/backend/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/compareNodes.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareNodes = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const visitor_keys_1 = require("@typescript-eslint/visitor-keys");
+function compareArrays(arrayA, arrayB) {
+    if (arrayA.length !== arrayB.length) {
+        return "Invalid" /* NodeComparisonResult.Invalid */;
+    }
+    const result = arrayA.every((elA, idx) => {
+        const elB = arrayB[idx];
+        if (elA == null || elB == null) {
+            return elA === elB;
+        }
+        return compareUnknownValues(elA, elB) === "Equal" /* NodeComparisonResult.Equal */;
+    });
+    if (result) {
+        return "Equal" /* NodeComparisonResult.Equal */;
+    }
+    return "Invalid" /* NodeComparisonResult.Invalid */;
+}
+function isValidNode(x) {
+    return (typeof x === 'object' &&
+        x != null &&
+        'type' in x &&
+        typeof x.type === 'string');
+}
+function isValidChainExpressionToLookThrough(node) {
+    return (!(node.parent?.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        node.parent.object === node) &&
+        !(node.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+            node.parent.callee === node) &&
+        node.type === utils_1.AST_NODE_TYPES.ChainExpression);
+}
+function compareUnknownValues(valueA, valueB) {
+    /* istanbul ignore if -- not possible for us to test this - it's just a sanity safeguard */
+    if (valueA == null || valueB == null) {
+        if (valueA !== valueB) {
+            return "Invalid" /* NodeComparisonResult.Invalid */;
+        }
+        return "Equal" /* NodeComparisonResult.Equal */;
+    }
+    /* istanbul ignore if -- not possible for us to test this - it's just a sanity safeguard */
+    if (!isValidNode(valueA) || !isValidNode(valueB)) {
+        return "Invalid" /* NodeComparisonResult.Invalid */;
+    }
+    return compareNodes(valueA, valueB);
+}
+function compareByVisiting(nodeA, nodeB) {
+    const currentVisitorKeys = visitor_keys_1.visitorKeys[nodeA.type];
+    /* istanbul ignore if -- not possible for us to test this - it's just a sanity safeguard */
+    if (currentVisitorKeys == null) {
+        // we don't know how to visit this node, so assume it's invalid to avoid false-positives / broken fixers
+        return "Invalid" /* NodeComparisonResult.Invalid */;
+    }
+    if (currentVisitorKeys.length === 0) {
+        // assume nodes with no keys are constant things like keywords
+        return "Equal" /* NodeComparisonResult.Equal */;
+    }
+    for (const key of currentVisitorKeys) {
+        // @ts-expect-error - dynamic access but it's safe
+        const nodeAChildOrChildren = nodeA[key];
+        // @ts-expect-error - dynamic access but it's safe
+        const nodeBChildOrChildren = nodeB[key];
+        if (Array.isArray(nodeAChildOrChildren)) {
+            const arrayA = nodeAChildOrChildren;
+            const arrayB = nodeBChildOrChildren;
+            const result = compareArrays(arrayA, arrayB);
+            if (result !== "Equal" /* NodeComparisonResult.Equal */) {
+                return "Invalid" /* NodeComparisonResult.Invalid */;
+            }
+            // fallthrough to the next key as the key was "equal"
+        }
+        else {
+            const result = compareUnknownValues(nodeAChildOrChildren, nodeBChildOrChildren);
+            if (result !== "Equal" /* NodeComparisonResult.Equal */) {
+                return "Invalid" /* NodeComparisonResult.Invalid */;
+            }
+            // fallthrough to the next key as the key was "equal"
+        }
+    }
+    return "Equal" /* NodeComparisonResult.Equal */;
+}
+function compareNodesUncached(nodeA, nodeB) {
+    if (nodeA.type !== nodeB.type) {
+        // special cases where nodes are allowed to be non-equal
+        // look through a chain expression node at the top-level because it only
+        // exists to delimit the end of an optional chain
+        //
+        // a?.b && a.b.c
+        // ^^^^ ChainExpression, MemberExpression
+        //         ^^^^^ MemberExpression
+        //
+        // except for in this class of cases
+        // (a?.b).c && a.b.c
+        // because the parentheses have runtime meaning (sad face)
+        if (isValidChainExpressionToLookThrough(nodeA)) {
+            return compareNodes(nodeA.expression, nodeB);
+        }
+        if (isValidChainExpressionToLookThrough(nodeB)) {
+            return compareNodes(nodeA, nodeB.expression);
+        }
+        // look through the type-only non-null assertion because its existence could
+        // possibly be replaced by an optional chain instead
+        //
+        // a.b! && a.b.c
+        // ^^^^ TSNonNullExpression
+        if (nodeA.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
+            return compareNodes(nodeA.expression, nodeB);
+        }
+        if (nodeB.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
+            return compareNodes(nodeA, nodeB.expression);
+        }
+        // special case for subset optional chains where the node types don't match,
+        // but we want to try comparing by discarding the "extra" code
+        //
+        // a && a.b
+        //      ^ compare this
+        // a && a()
+        //      ^ compare this
+        // a.b && a.b()
+        //        ^^^ compare this
+        // a() && a().b
+        //        ^^^ compare this
+        // import.meta && import.meta.b
+        //                ^^^^^^^^^^^ compare this
+        if (nodeA.type === utils_1.AST_NODE_TYPES.CallExpression ||
+            nodeA.type === utils_1.AST_NODE_TYPES.Identifier ||
+            nodeA.type === utils_1.AST_NODE_TYPES.MemberExpression ||
+            nodeA.type === utils_1.AST_NODE_TYPES.MetaProperty) {
+            switch (nodeB.type) {
+                case utils_1.AST_NODE_TYPES.MemberExpression:
+                    if (nodeB.property.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+                        // Private identifiers in optional chaining is not currently allowed
+                        // TODO - handle this once TS supports it (https://github.com/microsoft/TypeScript/issues/42734)
+                        return "Invalid" /* NodeComparisonResult.Invalid */;
+                    }
+                    if (compareNodes(nodeA, nodeB.object) !== "Invalid" /* NodeComparisonResult.Invalid */) {
+                        return "Subset" /* NodeComparisonResult.Subset */;
+                    }
+                    return "Invalid" /* NodeComparisonResult.Invalid */;
+                case utils_1.AST_NODE_TYPES.CallExpression:
+                    if (compareNodes(nodeA, nodeB.callee) !== "Invalid" /* NodeComparisonResult.Invalid */) {
+                        return "Subset" /* NodeComparisonResult.Subset */;
+                    }
+                    return "Invalid" /* NodeComparisonResult.Invalid */;
+                default:
+                    return "Invalid" /* NodeComparisonResult.Invalid */;
+            }
+        }
+        return "Invalid" /* NodeComparisonResult.Invalid */;
+    }
+    switch (nodeA.type) {
+        // these expressions create a new instance each time - so it makes no sense to compare the chain
+        case utils_1.AST_NODE_TYPES.ArrayExpression:
+        case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+        case utils_1.AST_NODE_TYPES.ClassExpression:
+        case utils_1.AST_NODE_TYPES.FunctionExpression:
+        case utils_1.AST_NODE_TYPES.JSXElement:
+        case utils_1.AST_NODE_TYPES.JSXFragment:
+        case utils_1.AST_NODE_TYPES.NewExpression:
+        case utils_1.AST_NODE_TYPES.ObjectExpression:
+            return "Invalid" /* NodeComparisonResult.Invalid */;
+        // chaining from assignments could change the value irrevocably - so it makes no sense to compare the chain
+        case utils_1.AST_NODE_TYPES.AssignmentExpression:
+            return "Invalid" /* NodeComparisonResult.Invalid */;
+        case utils_1.AST_NODE_TYPES.CallExpression: {
+            const nodeBCall = nodeB;
+            // check for cases like
+            // foo() && foo()(bar)
+            // ^^^^^ nodeA
+            //          ^^^^^^^^^^ nodeB
+            // we don't want to check the arguments in this case
+            const aSubsetOfB = compareNodes(nodeA, nodeBCall.callee);
+            if (aSubsetOfB !== "Invalid" /* NodeComparisonResult.Invalid */) {
+                return "Subset" /* NodeComparisonResult.Subset */;
+            }
+            const calleeCompare = compareNodes(nodeA.callee, nodeBCall.callee);
+            if (calleeCompare !== "Equal" /* NodeComparisonResult.Equal */) {
+                return "Invalid" /* NodeComparisonResult.Invalid */;
+            }
+            // NOTE - we purposely ignore optional flag because for our purposes
+            // foo?.bar() && foo.bar?.()?.baz
+            // or
+            // foo.bar() && foo?.bar?.()?.baz
+            // are going to be exactly the same
+            const argumentCompare = compareArrays(nodeA.arguments, nodeBCall.arguments);
+            if (argumentCompare !== "Equal" /* NodeComparisonResult.Equal */) {
+                return "Invalid" /* NodeComparisonResult.Invalid */;
+            }
+            const typeParamCompare = compareNodes(nodeA.typeArguments, nodeBCall.typeArguments);
+            if (typeParamCompare === "Equal" /* NodeComparisonResult.Equal */) {
+                return "Equal" /* NodeComparisonResult.Equal */;
+            }
+            return "Invalid" /* NodeComparisonResult.Invalid */;
+        }
+        case utils_1.AST_NODE_TYPES.ChainExpression:
+            // special case handling for ChainExpression because it's allowed to be a subset
+            return compareNodes(nodeA, nodeB.expression);
+        case utils_1.AST_NODE_TYPES.Identifier:
+        case utils_1.AST_NODE_TYPES.PrivateIdentifier:
+            if (nodeA.name === nodeB.name) {
+                return "Equal" /* NodeComparisonResult.Equal */;
+            }
+            return "Invalid" /* NodeComparisonResult.Invalid */;
+        case utils_1.AST_NODE_TYPES.Literal: {
+            const nodeBLiteral = nodeB;
+            if (nodeA.raw === nodeBLiteral.raw &&
+                nodeA.value === nodeBLiteral.value) {
+                return "Equal" /* NodeComparisonResult.Equal */;
+            }
+            return "Invalid" /* NodeComparisonResult.Invalid */;
+        }
+        case utils_1.AST_NODE_TYPES.MemberExpression: {
+            const nodeBMember = nodeB;
+            if (nodeBMember.property.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+                // Private identifiers in optional chaining is not currently allowed
+                // TODO - handle this once TS supports it (https://github.com/microsoft/TypeScript/issues/42734)
+                return "Invalid" /* NodeComparisonResult.Invalid */;
+            }
+            // check for cases like
+            // foo.bar && foo.bar.baz
+            // ^^^^^^^ nodeA
+            //            ^^^^^^^^^^^ nodeB
+            // result === Equal
+            //
+            // foo.bar && foo.bar.baz.bam
+            // ^^^^^^^ nodeA
+            //            ^^^^^^^^^^^^^^^ nodeB
+            // result === Subset
+            //
+            // we don't want to check the property in this case
+            const aSubsetOfB = compareNodes(nodeA, nodeBMember.object);
+            if (aSubsetOfB !== "Invalid" /* NodeComparisonResult.Invalid */) {
+                return "Subset" /* NodeComparisonResult.Subset */;
+            }
+            if (nodeA.computed !== nodeBMember.computed) {
+                return "Invalid" /* NodeComparisonResult.Invalid */;
+            }
+            // NOTE - we purposely ignore optional flag because for our purposes
+            // foo?.bar && foo.bar?.baz
+            // or
+            // foo.bar && foo?.bar?.baz
+            // are going to be exactly the same
+            const objectCompare = compareNodes(nodeA.object, nodeBMember.object);
+            if (objectCompare !== "Equal" /* NodeComparisonResult.Equal */) {
+                return "Invalid" /* NodeComparisonResult.Invalid */;
+            }
+            return compareNodes(nodeA.property, nodeBMember.property);
+        }
+        case utils_1.AST_NODE_TYPES.TSTemplateLiteralType:
+        case utils_1.AST_NODE_TYPES.TemplateLiteral: {
+            const nodeBTemplate = nodeB;
+            const areQuasisEqual = nodeA.quasis.length === nodeBTemplate.quasis.length &&
+                nodeA.quasis.every((elA, idx) => {
+                    const elB = nodeBTemplate.quasis[idx];
+                    return elA.value.cooked === elB.value.cooked;
+                });
+            if (!areQuasisEqual) {
+                return "Invalid" /* NodeComparisonResult.Invalid */;
+            }
+            return "Equal" /* NodeComparisonResult.Equal */;
+        }
+        case utils_1.AST_NODE_TYPES.TemplateElement: {
+            const nodeBElement = nodeB;
+            if (nodeA.value.cooked === nodeBElement.value.cooked) {
+                return "Equal" /* NodeComparisonResult.Equal */;
+            }
+            return "Invalid" /* NodeComparisonResult.Invalid */;
+        }
+        // these aren't actually valid expressions.
+        // https://github.com/typescript-eslint/typescript-eslint/blob/20d7caee35ab84ae6381fdf04338c9e2b9e2bc48/packages/ast-spec/src/unions/Expression.ts#L37-L43
+        case utils_1.AST_NODE_TYPES.ArrayPattern:
+        case utils_1.AST_NODE_TYPES.ObjectPattern:
+            /* istanbul ignore next */
+            return "Invalid" /* NodeComparisonResult.Invalid */;
+        // update expression returns a number and also changes the value each time - so it makes no sense to compare the chain
+        case utils_1.AST_NODE_TYPES.UpdateExpression:
+            return "Invalid" /* NodeComparisonResult.Invalid */;
+        // yield returns the value passed to the `next` function, so it may not be the same each time - so it makes no sense to compare the chain
+        case utils_1.AST_NODE_TYPES.YieldExpression:
+            return "Invalid" /* NodeComparisonResult.Invalid */;
+        // general-case automatic handling of nodes to save us implementing every
+        // single case by hand. This just iterates the visitor keys to recursively
+        // check the children.
+        //
+        // Any specific logic cases or short-circuits should be listed as separate
+        // cases so that they don't fall into this generic handling
+        default:
+            return compareByVisiting(nodeA, nodeB);
+    }
+}
+const COMPARE_NODES_CACHE = new WeakMap();
+/**
+ * Compares two nodes' ASTs to determine if the A is equal to or a subset of B
+ */
+function compareNodes(nodeA, nodeB) {
+    if (nodeA == null || nodeB == null) {
+        if (nodeA !== nodeB) {
+            return "Invalid" /* NodeComparisonResult.Invalid */;
+        }
+        return "Equal" /* NodeComparisonResult.Equal */;
+    }
+    const cached = COMPARE_NODES_CACHE.get(nodeA)?.get(nodeB);
+    if (cached) {
+        return cached;
+    }
+    const result = compareNodesUncached(nodeA, nodeB);
+    let mapA = COMPARE_NODES_CACHE.get(nodeA);
+    if (mapA == null) {
+        mapA = new WeakMap();
+        COMPARE_NODES_CACHE.set(nodeA, mapA);
+    }
+    mapA.set(nodeB, result);
+    return result;
+}
+exports.compareNodes = compareNodes;
+//# sourceMappingURL=compareNodes.js.map

package/backend/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/compareNodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareNodes.js","sourceRoot":"","sources":["../../../src/rules/prefer-optional-chain-utils/compareNodes.ts"],"names":[],"mappings":"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"}

package/backend/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.js

@@ -0,0 +1,279 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatherLogicalOperands = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const ts_api_utils_1 = require("ts-api-utils");
+const ts = __importStar(require("typescript"));
+const util_1 = require("../../util");
+const NULLISH_FLAGS = ts.TypeFlags.Null | ts.TypeFlags.Undefined;
+function isValidFalseBooleanCheckType(node, operator, checkType, parserServices, options) {
+    const type = parserServices.getTypeAtLocation(node);
+    const types = (0, ts_api_utils_1.unionTypeParts)(type);
+    const disallowFalseyLiteral = (operator === '||' && checkType === 'false') ||
+        (operator === '&&' && checkType === 'true');
+    if (disallowFalseyLiteral) {
+        /*
+        ```
+        declare const x: false | {a: string};
+        x && x.a;
+        !x || x.a;
+        ```
+    
+        We don't want to consider these two cases because the boolean expression
+        narrows out the non-nullish falsy cases - so converting the chain to `x?.a`
+        would introduce a build error
+        */
+        if (types.some(t => (0, ts_api_utils_1.isBooleanLiteralType)(t) && t.intrinsicName === 'false') ||
+            types.some(t => (0, ts_api_utils_1.isStringLiteralType)(t) && t.value === '') ||
+            types.some(t => (0, ts_api_utils_1.isNumberLiteralType)(t) && t.value === 0) ||
+            types.some(t => (0, ts_api_utils_1.isBigIntLiteralType)(t) && t.value.base10Value === '0')) {
+            return false;
+        }
+    }
+    if (options.requireNullish === true) {
+        return types.some(t => (0, util_1.isTypeFlagSet)(t, NULLISH_FLAGS));
+    }
+    let allowedFlags = NULLISH_FLAGS | ts.TypeFlags.Object;
+    if (options.checkAny === true) {
+        allowedFlags |= ts.TypeFlags.Any;
+    }
+    if (options.checkUnknown === true) {
+        allowedFlags |= ts.TypeFlags.Unknown;
+    }
+    if (options.checkString === true) {
+        allowedFlags |= ts.TypeFlags.StringLike;
+    }
+    if (options.checkNumber === true) {
+        allowedFlags |= ts.TypeFlags.NumberLike;
+    }
+    if (options.checkBoolean === true) {
+        allowedFlags |= ts.TypeFlags.BooleanLike;
+    }
+    if (options.checkBigInt === true) {
+        allowedFlags |= ts.TypeFlags.BigIntLike;
+    }
+    return types.every(t => (0, util_1.isTypeFlagSet)(t, allowedFlags));
+}
+function gatherLogicalOperands(node, parserServices, options) {
+    const result = [];
+    const { operands, newlySeenLogicals } = flattenLogicalOperands(node);
+    for (const operand of operands) {
+        switch (operand.type) {
+            case utils_1.AST_NODE_TYPES.BinaryExpression: {
+                // check for "yoda" style logical: null != x
+                const { comparedExpression, comparedValue, isYoda } = (() => {
+                    // non-yoda checks are by far the most common, so check for them first
+                    const comparedValueRight = getComparisonValueType(operand.right);
+                    if (comparedValueRight) {
+                        return {
+                            comparedExpression: operand.left,
+                            comparedValue: comparedValueRight,
+                            isYoda: false,
+                        };
+                    }
+                    return {
+                        comparedExpression: operand.right,
+                        comparedValue: getComparisonValueType(operand.left),
+                        isYoda: true,
+                    };
+                })();
+                if (comparedValue === "UndefinedStringLiteral" /* ComparisonValueType.UndefinedStringLiteral */) {
+                    if (comparedExpression.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                        comparedExpression.operator === 'typeof') {
+                        // typeof x === 'undefined'
+                        result.push({
+                            type: "Valid" /* OperandValidity.Valid */,
+                            comparedName: comparedExpression.argument,
+                            comparisonType: operand.operator.startsWith('!')
+                                ? "NotStrictEqualUndefined" /* NullishComparisonType.NotStrictEqualUndefined */
+                                : "StrictEqualUndefined" /* NullishComparisonType.StrictEqualUndefined */,
+                            isYoda,
+                            node: operand,
+                        });
+                        continue;
+                    }
+                    // y === 'undefined'
+                    result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                    continue;
+                }
+                switch (operand.operator) {
+                    case '!=':
+                    case '==':
+                        if (comparedValue === "Null" /* ComparisonValueType.Null */ ||
+                            comparedValue === "Undefined" /* ComparisonValueType.Undefined */) {
+                            // x == null, x == undefined
+                            result.push({
+                                type: "Valid" /* OperandValidity.Valid */,
+                                comparedName: comparedExpression,
+                                comparisonType: operand.operator.startsWith('!')
+                                    ? "NotEqualNullOrUndefined" /* NullishComparisonType.NotEqualNullOrUndefined */
+                                    : "EqualNullOrUndefined" /* NullishComparisonType.EqualNullOrUndefined */,
+                                isYoda,
+                                node: operand,
+                            });
+                            continue;
+                        }
+                        // x == something :(
+                        result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                        continue;
+                    case '!==':
+                    case '===': {
+                        const comparedName = comparedExpression;
+                        switch (comparedValue) {
+                            case "Null" /* ComparisonValueType.Null */:
+                                result.push({
+                                    type: "Valid" /* OperandValidity.Valid */,
+                                    comparedName,
+                                    comparisonType: operand.operator.startsWith('!')
+                                        ? "NotStrictEqualNull" /* NullishComparisonType.NotStrictEqualNull */
+                                        : "StrictEqualNull" /* NullishComparisonType.StrictEqualNull */,
+                                    isYoda,
+                                    node: operand,
+                                });
+                                continue;
+                            case "Undefined" /* ComparisonValueType.Undefined */:
+                                result.push({
+                                    type: "Valid" /* OperandValidity.Valid */,
+                                    comparedName,
+                                    comparisonType: operand.operator.startsWith('!')
+                                        ? "NotStrictEqualUndefined" /* NullishComparisonType.NotStrictEqualUndefined */
+                                        : "StrictEqualUndefined" /* NullishComparisonType.StrictEqualUndefined */,
+                                    isYoda,
+                                    node: operand,
+                                });
+                                continue;
+                            default:
+                                // x === something :(
+                                result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                                continue;
+                        }
+                    }
+                }
+                result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                continue;
+            }
+            case utils_1.AST_NODE_TYPES.UnaryExpression:
+                if (operand.operator === '!' &&
+                    isValidFalseBooleanCheckType(operand.argument, node.operator, 'false', parserServices, options)) {
+                    result.push({
+                        type: "Valid" /* OperandValidity.Valid */,
+                        comparedName: operand.argument,
+                        comparisonType: "NotBoolean" /* NullishComparisonType.NotBoolean */,
+                        isYoda: false,
+                        node: operand,
+                    });
+                    continue;
+                }
+                result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                continue;
+            case utils_1.AST_NODE_TYPES.LogicalExpression:
+                // explicitly ignore the mixed logical expression cases
+                result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                continue;
+            default:
+                if (isValidFalseBooleanCheckType(operand, node.operator, 'true', parserServices, options)) {
+                    result.push({
+                        type: "Valid" /* OperandValidity.Valid */,
+                        comparedName: operand,
+                        comparisonType: "Boolean" /* NullishComparisonType.Boolean */,
+                        isYoda: false,
+                        node: operand,
+                    });
+                }
+                else {
+                    result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                }
+                continue;
+        }
+    }
+    return {
+        operands: result,
+        newlySeenLogicals,
+    };
+    /*
+    The AST is always constructed such the first element is always the deepest element.
+    I.e. for this code: `foo && foo.bar && foo.bar.baz && foo.bar.baz.buzz`
+    The AST will look like this:
+    {
+      left: {
+        left: {
+          left: foo
+          right: foo.bar
+        }
+        right: foo.bar.baz
+      }
+      right: foo.bar.baz.buzz
+    }
+  
+    So given any logical expression, we can perform a depth-first traversal to get
+    the operands in order.
+  
+    Note that this function purposely does not inspect mixed logical expressions
+    like `foo || foo.bar && foo.bar.baz` - separate selector
+    */
+    function flattenLogicalOperands(node) {
+        const operands = [];
+        const newlySeenLogicals = new Set([node]);
+        const stack = [node.right, node.left];
+        let current;
+        while ((current = stack.pop())) {
+            if (current.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+                current.operator === node.operator) {
+                newlySeenLogicals.add(current);
+                stack.push(current.right);
+                stack.push(current.left);
+            }
+            else {
+                operands.push(current);
+            }
+        }
+        return {
+            operands,
+            newlySeenLogicals,
+        };
+    }
+    function getComparisonValueType(node) {
+        switch (node.type) {
+            case utils_1.AST_NODE_TYPES.Literal:
+                // eslint-disable-next-line eqeqeq -- intentional exact comparison against null
+                if (node.value === null && node.raw === 'null') {
+                    return "Null" /* ComparisonValueType.Null */;
+                }
+                if (node.value === 'undefined') {
+                    return "UndefinedStringLiteral" /* ComparisonValueType.UndefinedStringLiteral */;
+                }
+                return null;
+            case utils_1.AST_NODE_TYPES.Identifier:
+                if (node.name === 'undefined') {
+                    return "Undefined" /* ComparisonValueType.Undefined */;
+                }
+                return null;
+        }
+        return null;
+    }
+}
+exports.gatherLogicalOperands = gatherLogicalOperands;
+//# sourceMappingURL=gatherLogicalOperands.js.map

package/backend/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gatherLogicalOperands.js","sourceRoot":"","sources":["../../../src/rules/prefer-optional-chain-utils/gatherLogicalOperands.ts"],"names":[],"mappings":"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"}