@blumintinc/eslint-plugin-blumint 1.20.95 → 1.20.97

package/lib/rules/global-const-style.js

@@ -23,6 +23,28 @@ const toUpperSnakeCase = (name) => name
     .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
     .toUpperCase()
     .replace(/^_/, '');
+// `x as T`, `<T>x`, `x satisfies T` and `x!` annotate or assert an expression
+// without contributing a value of their own, so a check that classifies the
+// *shape* of an initializer must look through all four alike. Recognizing only
+// some of them makes the rule's carve-outs depend on which type syntax an
+// author happened to reach for: a React component written
+// `memo(Foo) satisfies ComponentType` or `memo(Foo)!` read as opaque
+// expressions and were renamed to UPPER_SNAKE_CASE while `memo(Foo) as FC` was
+// exempt (Issue #1681).
+const VALUE_WRAPPER_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSTypeAssertion,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+]);
+const isValueWrapper = (node) => VALUE_WRAPPER_TYPES.has(node.type);
+const unwrapValueWrappers = (node) => {
+    let target = node;
+    while (isValueWrapper(target)) {
+        target = target.expression;
+    }
+    return target;
+};
 // Jest mock handles produced by an `as` cast to a `jest.Mock*` type are
 // stateful test doubles that are reassigned/mutated through
 // `.mockImplementation()`, `.mockReturnValue()`, etc. They are not immutable
@@ -38,11 +60,7 @@ const JEST_MOCK_TYPE_NAMES = new Set([
 // `jest.Mocked<...>` / `jest.MockedClass<...>`. The match is kept deliberately
 // narrow — a qualified `jest.<MockType>` type reference — so unrelated `as`
 // casts keep triggering the rename check.
-const isJestMockCast = (node) => {
-    if (node.type !== utils_1.AST_NODE_TYPES.TSAsExpression) {
-        return false;
-    }
-    const typeAnnotation = node.typeAnnotation;
+const isJestMockTypeReference = (typeAnnotation) => {
     if (typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeReference) {
         return false;
     }
@@ -53,6 +71,43 @@ const isJestMockCast = (node) => {
         typeName.right.type === utils_1.AST_NODE_TYPES.Identifier &&
         JEST_MOCK_TYPE_NAMES.has(typeName.right.name));
 };
+// The cast can sit anywhere in a wrapper chain (`(foo as jest.Mock)!`,
+// `foo as jest.Mock satisfies unknown`), so the whole chain is scanned rather
+// than the outermost node alone — a mock handle stays a mock handle whatever is
+// wrapped around the cast.
+const isJestMockCast = (node) => {
+    let current = node;
+    while (isValueWrapper(current)) {
+        if (current.type === utils_1.AST_NODE_TYPES.TSAsExpression &&
+            isJestMockTypeReference(current.typeAnnotation)) {
+            return true;
+        }
+        current = current.expression;
+    }
+    return false;
+};
+// React's component factories, called bare (`memo(Foo)`) or through a namespace
+// import (`React.memo(Foo)`).
+const COMPONENT_FACTORY_NAMES = new Set(['forwardRef', 'memo']);
+const isComponentFactoryCall = (node) => {
+    if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+        return false;
+    }
+    const { callee } = node;
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return COMPONENT_FACTORY_NAMES.has(callee.name);
+    }
+    return (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        COMPONENT_FACTORY_NAMES.has(callee.property.name));
+};
+// A function value is a component, hook or helper, never the module-level
+// configuration value this rule governs. The two spellings are interchangeable
+// at a declaration site, so `const Row = function (props) {...}` is exempt on
+// the same terms as `const Row = (props) => {...}` (Issue #1681).
+const isFunctionValue = (node) => node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+    node.type === utils_1.AST_NODE_TYPES.FunctionExpression;
 /**
  * Walks the scope chain upward from `scope` (inclusive) and reports whether
  * `targetName` is bound anywhere between `scope` and `stopScope` (inclusive).
@@ -141,7 +196,16 @@ exports.default = (0, createRule_1.createRule)({
         // Check if the file is a TypeScript file
         const isTypeScript = context.getFilename().endsWith('.ts') ||
             context.getFilename().endsWith('.tsx');
-        const unwrapAssertions = (node) => {
+        /**
+         * Strips `as`/`<T>` casts only, and is deliberately narrower than
+         * `unwrapValueWrappers`. The two carve-outs below — dynamic values and
+         * binding aliases — silence the rule entirely, so widening them to see
+         * through `!`/`satisfies` would newly exempt `const value = getValue()!`
+         * and `const alias = other!` from the rename check. That is a detection
+         * change of its own, distinct from the wrapper-blind component exemption
+         * `unwrapValueWrappers` cures (Issue #1681).
+         */
+        const unwrapCasts = (node) => {
             let target = node;
             while (target.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
                 target.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
@@ -150,7 +214,7 @@ exports.default = (0, createRule_1.createRule)({
             return target;
         };
         const isDynamicValue = (node) => {
-            const target = unwrapAssertions(node);
+            const target = unwrapCasts(node);
             if (target.type === utils_1.AST_NODE_TYPES.CallExpression ||
                 target.type === utils_1.AST_NODE_TYPES.NewExpression ||
                 target.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
@@ -174,18 +238,18 @@ exports.default = (0, createRule_1.createRule)({
          * such a re-export is preserving a name importers depend on and a
          * single-file fixer cannot rewrite them (Issue #1418).
          *
-         * The check unwraps assertions so a type-pinned alias (`x as Foo`,
+         * The check unwraps casts so a type-pinned alias (`x as Foo`,
          * `x as const`) is treated the same as the bare form. A `MemberExpression`
          * (`Foo.bar`) is deliberately not covered — it keeps whatever behavior
          * `isDynamicValue` already gives it.
          */
         const isBindingAlias = (node) => {
-            const target = unwrapAssertions(node);
+            const target = unwrapCasts(node);
             return (target.type === utils_1.AST_NODE_TYPES.Identifier &&
                 !PRIMITIVE_VALUE_GLOBALS.has(target.name));
         };
         const describeValueKind = (node) => {
-            const target = unwrapAssertions(node);
+            const target = unwrapValueWrappers(node);
             if (target.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
                 return 'an array literal';
             }
@@ -208,41 +272,22 @@ exports.default = (0, createRule_1.createRule)({
                     node.parent?.type !== utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
                     return;
                 }
-                // Skip if any declaration is a function component, arrow function, forwardRef, or memo
+                // Skip if any declaration is a function value (component, hook or
+                // helper) or a `memo`/`forwardRef` component factory call. The
+                // initializer is classified through any type wrappers, so the pinned
+                // forms (`… as FC`, `… satisfies ComponentType`, `…!`) are exempt on
+                // the same terms as the bare expression they wrap.
                 const shouldSkip = node.declarations.some((declaration) => {
                     if (declaration.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
                         return false;
                     }
-                    const name = declaration.id.name;
                     const init = declaration.init;
                     // Skip if no initializer
                     if (!init) {
                         return false;
                     }
-                    // Skip function components (uppercase name + arrow function)
-                    if (/^[A-Z]/.test(name) &&
-                        init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-                        return true;
-                    }
-                    // Skip any arrow function
-                    if (init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-                        return true;
-                    }
-                    // Skip forwardRef and memo calls
-                    if (init.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                        if (init.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            return ['forwardRef', 'memo'].includes(init.callee.name);
-                        }
-                    }
-                    // Skip type assertions on forwardRef and memo calls
-                    if (init.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
-                        const expression = init.expression;
-                        if (expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                            expression.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            return ['forwardRef', 'memo'].includes(expression.callee.name);
-                        }
-                    }
-                    return false;
+                    const target = unwrapValueWrappers(init);
+                    return isFunctionValue(target) || isComponentFactoryCall(target);
                 });
                 if (shouldSkip) {
                     return;
@@ -267,15 +312,19 @@ exports.default = (0, createRule_1.createRule)({
                         : '';
                     // Only check for as const in TypeScript files
                     if (isTypeScript) {
+                        // An `as const` anywhere in the wrapper chain already freezes the
+                        // value, including when a later wrapper hides it
+                        // (`{...} as const satisfies Config`, `({...} as const)!`).
                         const hasAsConstAssertion = (node) => {
                             let current = node;
-                            while (current &&
-                                (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
-                                    current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion)) {
-                                const { typeAnnotation } = current;
-                                if (typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                                    typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                    typeAnnotation.typeName.name === 'const') {
+                            while (isValueWrapper(current)) {
+                                if ((current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+                                    current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) &&
+                                    current.typeAnnotation.type ===
+                                        utils_1.AST_NODE_TYPES.TSTypeReference &&
+                                    current.typeAnnotation.typeName.type ===
+                                        utils_1.AST_NODE_TYPES.Identifier &&
+                                    current.typeAnnotation.typeName.name === 'const') {
                                     return true;
                                 }
                                 current = current.expression;
@@ -287,14 +336,15 @@ exports.default = (0, createRule_1.createRule)({
                             if (hasAsConstAssertion(node)) {
                                 return false;
                             }
-                            const target = unwrapAssertions(node);
-                            // Skip an initializer already wrapped in a non-`const` assertion
-                            // (`{...} as T`, `<T>{...}`, `{...} as unknown as T`). A `const`
-                            // assertion may only be applied to a literal, so appending one
-                            // after an assertion chain is TS1355 — the same failure mode the
-                            // regex/null/boolean carve-outs below exist for. Such a cast is
-                            // also the author pinning the type deliberately, exactly like the
-                            // `id.typeAnnotation` case skipped next.
+                            const target = unwrapValueWrappers(node);
+                            // Skip an initializer already wrapped in a non-`const` type
+                            // wrapper (`{...} as T`, `<T>{...}`, `{...} as unknown as T`,
+                            // `{...} satisfies T`, `{...}!`). A `const` assertion may only be
+                            // applied to a literal, so appending one after such a chain is
+                            // TS1355 — the same failure mode the regex/null/boolean carve-outs
+                            // below exist for. Such a wrapper is also the author pinning the
+                            // type deliberately, exactly like the `id.typeAnnotation` case
+                            // skipped next.
                             if (target !== node) {
                                 return false;
                             }

package/lib/rules/no-always-true-false-conditions.js

@@ -30,6 +30,28 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
         const evaluatedParentNodes = new Set();
         // Sentinel distinguishes "no const literal resolved" from valid literal values (including null/undefined)
         const NOT_FOUND = Symbol('literal-not-found');
+        const ASSERTION_EXPRESSION_TYPES = new Set([
+            utils_1.AST_NODE_TYPES.TSAsExpression,
+            utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+            utils_1.AST_NODE_TYPES.TSNonNullExpression,
+            utils_1.AST_NODE_TYPES.TSTypeAssertion,
+        ]);
+        /**
+         * Strips type/non-null assertions from an expression. An assertion only
+         * describes a value, so the value behind it is exactly as knowable as the
+         * value itself — `"a" as const` is *more* certain than `"a"`, never less.
+         * Every resolution site strips them, otherwise a wrapper silently retires
+         * detection: sibling fixers add `as const` to module-scope constants, so a
+         * resolver that stopped at the wrapper would go blind on each constant they
+         * touch.
+         */
+        function unwrapAssertions(node) {
+            let current = node;
+            while (ASSERTION_EXPRESSION_TYPES.has(current.type)) {
+                current = current.expression;
+            }
+            return current;
+        }
         /**
          * Walks the current scope chain to locate a variable by name so identifier
          * lookups can resolve const initializers even when declared in parent scopes.
@@ -71,11 +93,74 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                 return NOT_FOUND;
             }
             const initializer = definition.node.init;
-            if (initializer?.type === utils_1.AST_NODE_TYPES.Literal) {
-                return initializer.value;
+            if (!initializer) {
+                return NOT_FOUND;
+            }
+            const value = unwrapAssertions(initializer);
+            if (value.type === utils_1.AST_NODE_TYPES.Literal) {
+                return value.value;
             }
             return NOT_FOUND;
         }
+        /**
+         * A const binding freezes the binding, not the object it points at, so a
+         * resolved object literal only stays constant while every reference merely
+         * reads a property off it. Writing through a member expression, or handing
+         * the object to anything that can retain and mutate it, makes the property
+         * values unknowable from the declaration alone.
+         */
+        function isPropertyReadReference(reference) {
+            const { identifier } = reference;
+            const parent = identifier.parent;
+            if (!parent) {
+                return false;
+            }
+            // The declaration's own initialization write.
+            if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                parent.id === identifier) {
+                return true;
+            }
+            if (parent.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                parent.object !== identifier) {
+                return false;
+            }
+            const access = parent.parent?.type === utils_1.AST_NODE_TYPES.ChainExpression
+                ? parent.parent.parent
+                : parent.parent;
+            if (!access) {
+                return true;
+            }
+            const writesTheProperty = (access.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+                access.left === parent) ||
+                access.type === utils_1.AST_NODE_TYPES.UpdateExpression ||
+                (access.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                    access.operator === 'delete');
+            return !writesTheProperty;
+        }
+        /**
+         * Resolves an identifier to the object literal it is initialized with when
+         * declared as a const nothing can mutate. Returns undefined whenever the
+         * binding is absent, is not a const, is initialized with anything other
+         * than an object literal, or escapes to code that could rewrite it.
+         */
+        function resolveIdentifierObject(identifier) {
+            const variable = findVariableInScopes(identifier.name);
+            if (!variable) {
+                return undefined;
+            }
+            const definition = findConstIdentifierDefinition(variable, identifier.name);
+            if (!definition?.node.init) {
+                return undefined;
+            }
+            const initializer = unwrapAssertions(definition.node.init);
+            if (initializer.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return undefined;
+            }
+            if (!variable.references.every(isPropertyReadReference)) {
+                return undefined;
+            }
+            return initializer;
+        }
         /**
          * Checks if a literal value is always truthy or falsy
          */
@@ -95,6 +180,117 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                     return {};
             }
         }
+        /**
+         * Classifies an expression that a constant declaration binds, so a resolved
+         * property value is judged by what it is rather than by where it was found.
+         * Anything whose value depends on runtime state stays unresolved.
+         */
+        function checkConstantValue(node) {
+            const value = unwrapAssertions(node);
+            switch (value.type) {
+                case utils_1.AST_NODE_TYPES.Literal:
+                    // A regex literal is an object, and its `value` is unusable when the
+                    // linting runtime cannot construct the pattern.
+                    return 'regex' in value
+                        ? { isTruthy: true }
+                        : checkLiteralValue(value);
+                case utils_1.AST_NODE_TYPES.ObjectExpression:
+                case utils_1.AST_NODE_TYPES.ArrayExpression:
+                case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+                case utils_1.AST_NODE_TYPES.FunctionExpression:
+                case utils_1.AST_NODE_TYPES.ClassExpression:
+                    return { isTruthy: true };
+                case utils_1.AST_NODE_TYPES.TemplateLiteral:
+                    return value.expressions.length === 0
+                        ? value.quasis[0].value.raw === ''
+                            ? { isFalsy: true }
+                            : { isTruthy: true }
+                        : {};
+                default:
+                    return {};
+            }
+        }
+        /**
+         * Reads the property name a member expression accesses. Returns undefined
+         * when the key is computed from something other than a literal, since the
+         * accessed property is then unknown at lint time.
+         */
+        function memberPropertyName(member) {
+            if (member.computed) {
+                const key = unwrapAssertions(member.property);
+                return key.type === utils_1.AST_NODE_TYPES.Literal &&
+                    (typeof key.value === 'string' || typeof key.value === 'number')
+                    ? String(key.value)
+                    : undefined;
+            }
+            return member.property.type === utils_1.AST_NODE_TYPES.Identifier
+                ? member.property.name
+                : undefined;
+        }
+        /**
+         * Reads the key an object literal property declares, mirroring the member
+         * access side so both are compared as strings.
+         */
+        function propertyKeyName(property) {
+            const { key } = property;
+            if (key.type === utils_1.AST_NODE_TYPES.Literal &&
+                (typeof key.value === 'string' || typeof key.value === 'number')) {
+                return String(key.value);
+            }
+            return !property.computed && key.type === utils_1.AST_NODE_TYPES.Identifier
+                ? key.name
+                : undefined;
+        }
+        /**
+         * Evaluates a property read against a resolved object literal. The result
+         * stays empty whenever the literal's shape hides the answer — a spread, a
+         * key computed at runtime, an accessor — and whenever the property is
+         * absent, because a missing own property can still resolve through the
+         * prototype chain (`config.toString`) or through declaration merging.
+         */
+        function checkObjectPropertyAccess(objectExpression, member) {
+            const propertyName = memberPropertyName(member);
+            if (propertyName === undefined) {
+                return {};
+            }
+            let resolvedValue;
+            for (const property of objectExpression.properties) {
+                if (property.type !== utils_1.AST_NODE_TYPES.Property) {
+                    // A spread can contribute or overwrite any key.
+                    return {};
+                }
+                const keyName = propertyKeyName(property);
+                if (keyName === undefined) {
+                    return {};
+                }
+                if (keyName === propertyName) {
+                    if (property.kind !== 'init') {
+                        // An accessor returns whatever it likes.
+                        return {};
+                    }
+                    // A later duplicate key wins.
+                    resolvedValue = property.value;
+                }
+            }
+            return resolvedValue ? checkConstantValue(resolvedValue) : {};
+        }
+        /**
+         * Evaluates a member access whose object the rule can pin to an object
+         * literal, whether the literal is written inline or reached through a const
+         * binding. Optional chaining off such an object behaves like plain access,
+         * because the object is known not to be nullish.
+         */
+        function checkMemberAccess(member) {
+            const object = unwrapAssertions(member.object);
+            if (object.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return checkObjectPropertyAccess(object, member);
+            }
+            if (object.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const resolved = resolveIdentifierObject(object);
+                return resolved ? checkObjectPropertyAccess(resolved, member) : {};
+            }
+            return {};
+        }
         const MATH_FOLDABLE_METHODS = new Set(['max', 'min']);
         /**
          * Resolves a `Math.max`/`Math.min` call over numeric literals to the number
@@ -130,11 +326,12 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
          * Returns undefined when the operand depends on runtime values.
          */
         function resolveNumericOperand(node) {
-            if (node.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof node.value === 'number') {
-                return node.value;
+            const operand = unwrapAssertions(node);
+            if (operand.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof operand.value === 'number') {
+                return operand.value;
             }
-            return evaluateMathMinMaxCall(node);
+            return evaluateMathMinMaxCall(operand);
         }
         function compareNumericValues(leftValue, operator, rightValue) {
             switch (operator) {
@@ -172,13 +369,16 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
          * Checks if a binary expression with literals is always truthy or falsy
          */
         function checkBinaryExpression(node) {
+            // An assertion around an operand leaves the compared value untouched.
+            const left = unwrapAssertions(node.left);
+            const right = unwrapAssertions(node.right);
             // Check for bitwise operations
             if (node.operator === '&') {
-                if (node.left.type === utils_1.AST_NODE_TYPES.Literal &&
-                    node.right.type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof node.left.value === 'number' &&
-                    typeof node.right.value === 'number') {
-                    const result = node.left.value & node.right.value;
+                if (left.type === utils_1.AST_NODE_TYPES.Literal &&
+                    right.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof left.value === 'number' &&
+                    typeof right.value === 'number') {
+                    const result = left.value & right.value;
                     if (result === 0) {
                         return { isFalsy: true };
                     }
@@ -190,17 +390,17 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
             // A non-literal operand can still be a compile-time constant, so resolve
             // it before abandoning the comparison. Bailing out unconditionally here
             // hid every folded-call comparison (Math.max(1, 2) === 0) from the rule.
-            if (node.left.type !== utils_1.AST_NODE_TYPES.Literal ||
-                node.right.type !== utils_1.AST_NODE_TYPES.Literal) {
-                const resolvedLeft = resolveNumericOperand(node.left);
-                const resolvedRight = resolveNumericOperand(node.right);
+            if (left.type !== utils_1.AST_NODE_TYPES.Literal ||
+                right.type !== utils_1.AST_NODE_TYPES.Literal) {
+                const resolvedLeft = resolveNumericOperand(left);
+                const resolvedRight = resolveNumericOperand(right);
                 if (resolvedLeft === undefined || resolvedRight === undefined) {
                     return {};
                 }
                 return compareNumericValues(resolvedLeft, node.operator, resolvedRight);
             }
-            const leftValue = node.left.value;
-            const rightValue = node.right.value;
+            const leftValue = left.value;
+            const rightValue = right.value;
             // Skip if either value is null or undefined
             if (leftValue === null ||
                 leftValue === undefined ||
@@ -376,15 +576,6 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
             }
             return {};
         }
-        /**
-         * Check if a node is an "as const" expression
-         */
-        function isAsConstExpression(node) {
-            return (node.type === utils_1.AST_NODE_TYPES.TSAsExpression &&
-                node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                node.typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
-                node.typeAnnotation.typeName.name === 'const');
-        }
         /**
          * Check if a logical expression is being used for default value assignment
          * This includes patterns like:
@@ -870,6 +1061,11 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
             if (evaluatedParentNodes.has(node)) {
                 return {};
             }
+            // An assertion wrapper carries the same value as the expression inside it
+            const unwrapped = unwrapAssertions(node);
+            if (unwrapped !== node) {
+                return evaluateConstantExpression(unwrapped);
+            }
             // Check special constants and identifiers first
             const specialResult = checkSpecialValues(node);
             if (specialResult.isTruthy || specialResult.isFalsy) {
@@ -950,11 +1146,6 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                     return { isFalsy: true };
                 }
             }
-            // "as const" expressions
-            if (isAsConstExpression(node) &&
-                node.expression.type === utils_1.AST_NODE_TYPES.Literal) {
-                return checkLiteralValue(node.expression);
-            }
             // Special checks for const variables in tests
             if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
                 if (node.left.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -1056,38 +1247,16 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                     return evaluateConstantExpression(logicalNode.left);
                 }
             }
-            // Handle optional chaining with literal objects
+            // Optional chaining off an object the rule can pin to an object literal.
+            // The guard the operator adds is dead there, and the property it reads is
+            // as knowable as the literal that declares it, whatever the binding and
+            // the property are named. Anything else — a binding initialized from a
+            // call, a parameter, a value that may legitimately be undefined — stays
+            // unresolved.
             if (node.type === utils_1.AST_NODE_TYPES.ChainExpression &&
-                node.expression.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                if (node.expression.optional) {
-                    // Handle object?.prop
-                    if (
-                    // Only consider it always truthy if it's a literal object expression
-                    node.expression.object.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                        // If we have a property access and we know the object is a literal object
-                        return { isTruthy: true };
-                    }
-                    // Special case for identifiers that are explicitly defined in the same scope
-                    // This is to handle test cases like `const obj = { prop: "value" }; if (obj?.prop) {}`
-                    if (node.expression.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        node.expression.object.name === 'obj' &&
-                        node.expression.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        node.expression.property.name === 'prop') {
-                        // This is specifically for the test case "obj?.prop"
-                        return { isTruthy: true };
-                    }
-                    // Special case for array length checks with optional chaining
-                    // This handles cases like `filtered?.length` where filtered could be undefined
-                    if (node.expression.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        node.expression.property.name === 'length') {
-                        // For array length checks with optional chaining, we can't determine
-                        // if the condition is always truthy or falsy, so return empty result
-                        return {};
-                    }
-                    // For other cases like arrays, identifiers, etc., we can't determine
-                    // if the condition is always truthy or falsy, so return empty result
-                    return {};
-                }
+                node.expression.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.expression.optional) {
+                return checkMemberAccess(node.expression);
             }
             // Handle Object.keys().length
             if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression &&