@pobammer-ts/eslint-cease-nonsense-rules 1.4.0 → 1.4.2

package/dist/build-metadata.json

@@ -1,5 +1,5 @@
 {
-  "commit": "f4fa667fccc9bd1def0d63fcc3733e8170343d31",
-  "time": "2025-12-02T13:23:02.709Z",
-  "version": "1.4.0"
+  "commit": "b2b51c8d8ebea9ceb8a4cd943c1f35ecac632c5f",
+  "time": "2025-12-07T19:15:33.726Z",
+  "version": "1.4.2"
 }

package/dist/index.js

@@ -7289,7 +7289,8 @@ function FromObject13(context, type3, value) {
   const knownPropertyKeys = exports_guard.Keys(type3.properties);
   for (const key of knownPropertyKeys) {
     const propertyValue = FromType16(context, type3.properties[key], value[key]);
-    if (exports_guard.IsUndefined(propertyValue))
+    const isUnassignableUndefined = exports_guard.IsUndefined(propertyValue) && (IsOptional(type3.properties[key]) || !exports_guard.HasPropertyKey(type3.properties[key], "default"));
+    if (isUnassignableUndefined)
       continue;
     value[key] = FromType16(context, type3.properties[key], value[key]);
   }
@@ -10537,6 +10538,21 @@ var IS_FUNCTION_EXPRESSION = new Set([
   TSESTree8.AST_NODE_TYPES.FunctionExpression,
   TSESTree8.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
+var CONTROL_FLOW_TYPES = new Set([
+  TSESTree8.AST_NODE_TYPES.BlockStatement,
+  TSESTree8.AST_NODE_TYPES.IfStatement,
+  TSESTree8.AST_NODE_TYPES.SwitchStatement,
+  TSESTree8.AST_NODE_TYPES.SwitchCase,
+  TSESTree8.AST_NODE_TYPES.TryStatement,
+  TSESTree8.AST_NODE_TYPES.CatchClause,
+  TSESTree8.AST_NODE_TYPES.WhileStatement,
+  TSESTree8.AST_NODE_TYPES.DoWhileStatement,
+  TSESTree8.AST_NODE_TYPES.ForStatement,
+  TSESTree8.AST_NODE_TYPES.ForInStatement,
+  TSESTree8.AST_NODE_TYPES.ForOfStatement,
+  TSESTree8.AST_NODE_TYPES.LabeledStatement,
+  TSESTree8.AST_NODE_TYPES.WithStatement
+]);
 function isTopLevelReturn(node) {
   let parent = ascendPastWrappers(node.parent);
   if (!parent)
@@ -10555,7 +10571,7 @@ function isTopLevelReturn(node) {
     return false;
   if (parent.type === TSESTree8.AST_NODE_TYPES.ReturnStatement) {
     let currentNode = ascendPastWrappers(parent.parent);
-    if (currentNode?.type === TSESTree8.AST_NODE_TYPES.BlockStatement)
+    while (currentNode && CONTROL_FLOW_TYPES.has(currentNode.type))
       currentNode = ascendPastWrappers(currentNode.parent);
     if (!currentNode)
       return false;
@@ -10614,6 +10630,25 @@ function isJSXPropValue(node) {
   }
   return parent.type === TSESTree8.AST_NODE_TYPES.JSXAttribute;
 }
+function isTernaryJSXChild(node) {
+  let current = node.parent;
+  if (!current)
+    return false;
+  let foundTernary = false;
+  while (current && (current.type === TSESTree8.AST_NODE_TYPES.ConditionalExpression || WRAPPER_PARENT_TYPES.has(current.type))) {
+    if (current.type === TSESTree8.AST_NODE_TYPES.ConditionalExpression)
+      foundTernary = true;
+    current = current.parent;
+  }
+  if (!foundTernary || !current)
+    return false;
+  if (current.type !== TSESTree8.AST_NODE_TYPES.JSXExpressionContainer)
+    return false;
+  const containerParent = current.parent;
+  if (!containerParent)
+    return false;
+  return containerParent.type === TSESTree8.AST_NODE_TYPES.JSXElement || containerParent.type === TSESTree8.AST_NODE_TYPES.JSXFragment;
+}
 var docs3 = {
   description: "Enforce key props on all React elements except top-level returns",
   recommended: true
@@ -10643,6 +10678,8 @@ var requireReactComponentKeys = {
         return;
       if (isJSXPropValue(node))
         return;
+      if (isTernaryJSXChild(node))
+        return;
       if (node.type === TSESTree8.AST_NODE_TYPES.JSXFragment) {
         context.report({
           messageId: "missingKey",
@@ -10816,13 +10853,16 @@ function getHookName2(node) {
   const { callee } = node;
   if (callee.type === TSESTree9.AST_NODE_TYPES.Identifier)
     return callee.name;
-  if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier) {
     return callee.property.name;
+  }
   return;
 }
 function getMemberExpressionDepth(node) {
   let depth = 0;
   let current = node;
+  if (current.type === TSESTree9.AST_NODE_TYPES.ChainExpression)
+    current = current.expression;
   while (current.type === TSESTree9.AST_NODE_TYPES.MemberExpression) {
     depth += 1;
     current = current.object;
@@ -10831,23 +10871,53 @@ function getMemberExpressionDepth(node) {
 }
 function getRootIdentifier(node) {
   let current = node;
-  while (current.type === TSESTree9.AST_NODE_TYPES.MemberExpression)
-    current = current.object;
+  if (current.type === TSESTree9.AST_NODE_TYPES.ChainExpression)
+    current = current.expression;
+  while (current.type === TSESTree9.AST_NODE_TYPES.MemberExpression || current.type === TSESTree9.AST_NODE_TYPES.TSNonNullExpression) {
+    if (current.type === TSESTree9.AST_NODE_TYPES.MemberExpression)
+      current = current.object;
+    else
+      current = current.expression;
+  }
   return current.type === TSESTree9.AST_NODE_TYPES.Identifier ? current : undefined;
 }
 function nodeToDependencyString(node, sourceCode) {
   return sourceCode.getText(node);
 }
+function nodeToSafeDependencyPath(node, sourceCode) {
+  if (node.type === TSESTree9.AST_NODE_TYPES.Identifier)
+    return node.name;
+  if (node.type === TSESTree9.AST_NODE_TYPES.ChainExpression) {
+    return nodeToSafeDependencyPath(node.expression, sourceCode);
+  }
+  if (TS_RUNTIME_EXPRESSIONS.has(node.type)) {
+    const expr = node;
+    return nodeToSafeDependencyPath(expr.expression, sourceCode);
+  }
+  if (node.type === TSESTree9.AST_NODE_TYPES.MemberExpression) {
+    const objectPath = nodeToSafeDependencyPath(node.object, sourceCode);
+    if (node.computed) {
+      const propertyText = sourceCode.getText(node.property);
+      return `${objectPath}[${propertyText}]`;
+    }
+    const propertyName = node.property.type === TSESTree9.AST_NODE_TYPES.Identifier ? node.property.name : "";
+    const separator = node.optional ? "?." : ".";
+    return `${objectPath}${separator}${propertyName}`;
+  }
+  return sourceCode.getText(node);
+}
 function isStableArrayIndex(stableResult, node, identifierName) {
   if (!stableResult)
     return false;
-  if (!(stableResult instanceof Set) || node.type !== TSESTree9.AST_NODE_TYPES.VariableDeclarator || node.id.type !== TSESTree9.AST_NODE_TYPES.ArrayPattern)
+  if (!(stableResult instanceof Set) || node.type !== TSESTree9.AST_NODE_TYPES.VariableDeclarator || node.id.type !== TSESTree9.AST_NODE_TYPES.ArrayPattern) {
     return false;
+  }
   const elements = node.id.elements;
   let index2 = 0;
   for (const element of elements) {
-    if (element.type === TSESTree9.AST_NODE_TYPES.Identifier && element.name === identifierName)
+    if (element.type === TSESTree9.AST_NODE_TYPES.Identifier && element.name === identifierName) {
       return stableResult.has(index2);
+    }
     index2 += 1;
   }
   return false;
@@ -10883,16 +10953,20 @@ function isStableValue(variable, identifierName, stableHooks) {
         return true;
       if (init?.type === TSESTree9.AST_NODE_TYPES.CallExpression) {
         const { callee } = init;
-        if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.property.name === "joinBindings")
+        if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.property.name === "joinBindings") {
           return true;
-        if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.property.name === "map")
+        }
+        if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.property.name === "map") {
           return true;
+        }
       }
       if (init) {
-        if (init.type === TSESTree9.AST_NODE_TYPES.Literal || init.type === TSESTree9.AST_NODE_TYPES.TemplateLiteral)
+        if (init.type === TSESTree9.AST_NODE_TYPES.Literal || init.type === TSESTree9.AST_NODE_TYPES.TemplateLiteral) {
           return true;
-        if (init.type === TSESTree9.AST_NODE_TYPES.UnaryExpression && init.argument.type === TSESTree9.AST_NODE_TYPES.Literal)
+        }
+        if (init.type === TSESTree9.AST_NODE_TYPES.UnaryExpression && init.argument.type === TSESTree9.AST_NODE_TYPES.Literal) {
           return true;
+        }
       }
       const variableDefinition = variable.defs.find((definition2) => definition2.node === node);
       if (variableDefinition && variableDefinition.node.type === TSESTree9.AST_NODE_TYPES.VariableDeclarator) {
@@ -10909,7 +10983,17 @@ function isStableValue(variable, identifierName, stableHooks) {
 function findTopmostMemberExpression(node) {
   let current = node;
   let { parent } = node;
-  while (parent?.type === TSESTree9.AST_NODE_TYPES.MemberExpression && parent.object === current) {
+  while (parent) {
+    if (parent.type === TSESTree9.AST_NODE_TYPES.CallExpression && parent.callee === current) {
+      if (current.type === TSESTree9.AST_NODE_TYPES.MemberExpression)
+        return current.object;
+      break;
+    }
+    const isMemberParent = parent.type === TSESTree9.AST_NODE_TYPES.MemberExpression && parent.object === current;
+    const isChainParent = parent.type === TSESTree9.AST_NODE_TYPES.ChainExpression;
+    const isNonNullParent = parent.type === TSESTree9.AST_NODE_TYPES.TSNonNullExpression;
+    if (!isMemberParent && !isChainParent && !isNonNullParent)
+      break;
     current = parent;
     parent = parent.parent;
   }
@@ -10921,9 +11005,24 @@ var IS_CEASE_BOUNDARY = new Set([
   TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression,
   TSESTree9.AST_NODE_TYPES.VariableDeclarator
 ]);
+var TS_RUNTIME_EXPRESSIONS = new Set([
+  TSESTree9.AST_NODE_TYPES.TSNonNullExpression,
+  TSESTree9.AST_NODE_TYPES.TSAsExpression,
+  TSESTree9.AST_NODE_TYPES.TSSatisfiesExpression,
+  TSESTree9.AST_NODE_TYPES.TSTypeAssertion,
+  TSESTree9.AST_NODE_TYPES.TSInstantiationExpression
+]);
+function isComputedPropertyIdentifier(identifier3) {
+  const parent = identifier3.parent;
+  return parent?.type === TSESTree9.AST_NODE_TYPES.Property && parent.computed && parent.key === identifier3;
+}
 function isInTypePosition(identifier3) {
   let parent = identifier3.parent;
   while (parent) {
+    if (TS_RUNTIME_EXPRESSIONS.has(parent.type)) {
+      parent = parent.parent;
+      continue;
+    }
     if (parent.type.startsWith("TS"))
       return true;
     if (IS_CEASE_BOUNDARY.has(parent.type))
@@ -10969,10 +11068,12 @@ function resolveFunctionReference(identifier3, scope) {
     return;
   for (const definition of variable.defs) {
     const { node } = definition;
-    if (node.type === TSESTree9.AST_NODE_TYPES.FunctionDeclaration)
+    if (node.type === TSESTree9.AST_NODE_TYPES.FunctionDeclaration) {
       return node;
-    if (node.type === TSESTree9.AST_NODE_TYPES.VariableDeclarator && node.init && (node.init.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === TSESTree9.AST_NODE_TYPES.FunctionExpression))
+    }
+    if (node.type === TSESTree9.AST_NODE_TYPES.VariableDeclarator && node.init && (node.init.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === TSESTree9.AST_NODE_TYPES.FunctionExpression)) {
       return node.init;
+    }
   }
   return;
 }
@@ -11009,9 +11110,11 @@ function collectCaptures(node, sourceCode) {
           }
           captureSet.add(name);
           const depthNode = findTopmostMemberExpression(current);
-          const usagePath = sourceCode.getText(depthNode);
+          const usagePath = nodeToSafeDependencyPath(depthNode, sourceCode);
+          const depth = getMemberExpressionDepth(depthNode);
           captures.push({
-            depth: getMemberExpressionDepth(depthNode),
+            depth,
+            forceDependency: isComputedPropertyIdentifier(current),
             name,
             node: depthNode,
             usagePath,
@@ -11030,6 +11133,16 @@ function collectCaptures(node, sourceCode) {
         visit(current.property);
       return;
     }
+    if (current.type === TSESTree9.AST_NODE_TYPES.ChainExpression) {
+      visit(current.expression);
+      return;
+    }
+    if (current.type === TSESTree9.AST_NODE_TYPES.Property) {
+      if (current.computed)
+        visit(current.key);
+      visit(current.value);
+      return;
+    }
     const keys2 = sourceCode.visitorKeys?.[current.type] ?? [];
     for (const key of keys2) {
       const value = current[key];
@@ -11125,9 +11238,9 @@ var useExhaustiveDependencies = {
         if (closureArgument === undefined)
           return;
         let closureFunction;
-        if (closureArgument.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression || closureArgument.type === TSESTree9.AST_NODE_TYPES.FunctionExpression)
+        if (closureArgument.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression || closureArgument.type === TSESTree9.AST_NODE_TYPES.FunctionExpression) {
           closureFunction = closureArgument;
-        else if (closureArgument.type === TSESTree9.AST_NODE_TYPES.Identifier) {
+        } else if (closureArgument.type === TSESTree9.AST_NODE_TYPES.Identifier) {
           const scope = getScope(callNode);
           closureFunction = resolveFunctionReference(closureArgument, scope);
         }
@@ -11136,7 +11249,7 @@ var useExhaustiveDependencies = {
         const dependenciesArgument = parameters3[dependenciesIndex];
         if (!dependenciesArgument && options3.reportMissingDependenciesArray) {
           const captures2 = collectCaptures(closureFunction, context.sourceCode);
-          const requiredCaptures = captures2.filter((capture) => !isStableValue(capture.variable, capture.name, stableHooks));
+          const requiredCaptures = captures2.filter((capture) => capture.forceDependency || !isStableValue(capture.variable, capture.name, stableHooks));
           if (requiredCaptures.length > 0) {
             const missingNames = [...new Set(requiredCaptures.map(returnName))].join(", ");
             const usagePaths = requiredCaptures.map(({ usagePath }) => usagePath);
@@ -11213,8 +11326,9 @@ var useExhaustiveDependencies = {
         }
         const missingCaptures = new Array;
         for (const capture of captures) {
-          if (isStableValue(capture.variable, capture.name, stableHooks))
+          if (!capture.forceDependency && isStableValue(capture.variable, capture.name, stableHooks)) {
             continue;
+          }
           const rootIdentifier = getRootIdentifier(capture.node);
           if (!rootIdentifier)
             continue;
@@ -11269,8 +11383,9 @@ var useExhaustiveDependencies = {
           }
         }
         for (const capture of captures) {
-          if (isStableValue(capture.variable, capture.name, stableHooks))
+          if (!capture.forceDependency && isStableValue(capture.variable, capture.name, stableHooks)) {
             continue;
+          }
           const rootIdentifier = getRootIdentifier(capture.node);
           if (!rootIdentifier)
             continue;
@@ -13130,4 +13245,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=F981FE172662E0F564756E2164756E21
+//# debugId=37B24C45DE0AD08464756E2164756E21