es-check 9.6.4 → 9.7.2

package/lib/helpers/ast.js

@@ -1,16 +1,29 @@
+const {
+  ARRAY_CONSTRUCTOR_FUNCTIONS,
+  ARRAY_LIKE_NAMES,
+  ARRAY_METHODS,
+  COMMON_NON_ARRAY_NAMES,
+  COMMON_NON_SET_NAMES,
+  SET_LIKE_NAMES,
+} = require("../constants");
+
 function hasOptionsCause(node) {
   const args = node.arguments;
-  if (!args || args.length < 2) return false;
+  const hasTooFewArgs = !args || args.length < 2;
+  if (hasTooFewArgs) return false;
 
   const optionsArg = args[1];
   if (optionsArg?.type !== "ObjectExpression") return false;
 
-  return optionsArg.properties?.some(
-    (prop) =>
-      prop.type === "Property" &&
-      prop.key?.type === "Identifier" &&
-      prop.key?.name === "cause",
-  );
+  return optionsArg.properties?.some(isCauseProperty);
+}
+
+function isCauseProperty(prop) {
+  const isProperty = prop.type === "Property";
+  const hasIdentifierKey = prop.key?.type === "Identifier";
+  const isCauseKey = prop.key?.name === "cause";
+  const hasCauseProperty = isProperty && hasIdentifierKey && isCauseKey;
+  return hasCauseProperty;
 }
 
 function hasNumericArgument(node) {
@@ -19,76 +32,17 @@ function hasNumericArgument(node) {
   if (!hasArgs) return false;
 
   const arg = args[0];
-  const isNumericLiteral =
-    arg.type === "Literal" && typeof arg.value === "number";
+  const isNumericLiteral = arg.type === "Literal" && typeof arg.value === "number";
 
   const isUnaryExpression = arg.type === "UnaryExpression";
   const isNegationOperator = arg.operator === "-";
   const hasNumericLiteralArgument =
     arg.argument?.type === "Literal" && typeof arg.argument.value === "number";
-  const isNegativeNumeric =
-    isUnaryExpression && isNegationOperator && hasNumericLiteralArgument;
+  const isNegativeNumeric = isUnaryExpression && isNegationOperator && hasNumericLiteralArgument;
 
   return isNumericLiteral || isNegativeNumeric;
 }
 
-const ARRAY_LIKE_NAMES = new Set([
-  "arr",
-  "array",
-  "list",
-  "items",
-  "values",
-  "arguments",
-]);
-
-const ARRAY_CONSTRUCTOR_FUNCTIONS = new Set([
-  "Array",
-  "from",
-  "of",
-  "slice",
-  "filter",
-  "map",
-  "concat",
-]);
-
-const ARRAY_METHODS = new Set([
-  "slice",
-  "filter",
-  "map",
-  "concat",
-  "from",
-  "of",
-]);
-
-const COMMON_NON_ARRAY_NAMES = new Set([
-  "obj",
-  "object",
-  "foo",
-  "bar",
-  "baz",
-  "data",
-  "config",
-  "options",
-  "params",
-  "props",
-  "state",
-  "item",
-  "element",
-  "node",
-  "target",
-  "source",
-  "result",
-  "response",
-  "request",
-  "payload",
-  "model",
-  "view",
-  "controller",
-  "service",
-  "utils",
-  "helpers",
-  "custom",
-]);
 function isArrayExpression(calleeObject) {
   return calleeObject.type === "ArrayExpression";
 }
@@ -121,8 +75,7 @@ function isArrayConstructorCall(calleeObject) {
   if (isMemberExpressionCallee) {
     const innerProperty = innerCallee.property;
     const hasPropertyName = innerProperty?.name;
-    const isArrayMethod =
-      hasPropertyName && ARRAY_METHODS.has(innerProperty.name);
+    const isArrayMethod = hasPropertyName && ARRAY_METHODS.has(innerProperty.name);
     return isArrayMethod;
   }
 
@@ -144,42 +97,9 @@ function isArrayLikeCall(node) {
   return isArray;
 }
 
-// ── Set-like call detection (mirrors Array-like approach) ──
-
-const SET_LIKE_NAMES = new Set(["set", "sets", "seta", "setb", "set1", "set2"]);
-
-/**
- * Words that start/end with "set" but are not Set instances.
- * Used as a blocklist when the broader startsWith/endsWith heuristic is active.
- */
-const COMMON_NON_SET_NAMES = new Set([
-  "settings",
-  "setup",
-  "setter",
-  "setstate",
-  "setvalue",
-  "setdata",
-  "setitem",
-  "setinterval",
-  "settimeout",
-  "offset",
-  "dataset",
-  "reset",
-  "asset",
-  "charset",
-  "onset",
-  "subset",
-  "mindset",
-  "closet",
-  "baseset",
-]);
-
 function isSetConstructorCall(calleeObject) {
-  // new Set() or new Set([...])
-  if (
-    calleeObject.type === "NewExpression" &&
-    calleeObject.callee?.name === "Set"
-  ) {
+  const isNewSet = calleeObject.type === "NewExpression" && calleeObject.callee?.name === "Set";
+  if (isNewSet) {
     return true;
   }
   return false;
@@ -189,38 +109,41 @@ function isSetLikeIdentifier(calleeObject) {
   if (calleeObject.type !== "Identifier") return false;
   const name = calleeObject.name.toLowerCase();
   if (COMMON_NON_SET_NAMES.has(name)) return false;
-  return (
-    SET_LIKE_NAMES.has(name) || name.startsWith("set") || name.endsWith("set")
-  );
+  const hasKnownSetName = SET_LIKE_NAMES.has(name);
+  const hasSetPrefix = name.startsWith("set");
+  const hasSetSuffix = name.endsWith("set");
+  const isSetLike = hasKnownSetName || hasSetPrefix || hasSetSuffix;
+  return isSetLike;
 }
 
 function isSetLikeCall(node) {
   const calleeObject = node.callee?.object;
   if (!calleeObject) return false;
 
-  return (
-    isSetConstructorCall(calleeObject) || isSetLikeIdentifier(calleeObject)
-  );
+  return isSetConstructorCall(calleeObject) || isSetLikeIdentifier(calleeObject);
+}
+
+function getStaticPropertyName(node, property = node?.property) {
+  if (property?.type === "PrivateIdentifier") return null;
+  if (!node?.computed) return property?.name;
+  const isLiteral = property?.type === "Literal";
+  if (!isLiteral) return null;
+  return String(property.value);
 }
 
 function checkMap(node, astInfo) {
   const callee = node.callee;
   const calleeObject = callee?.object;
-  const calleeProperty = callee?.property;
   const calleeObjectName = calleeObject?.name;
-  const calleePropertyName = calleeProperty?.name;
+  const calleePropertyName = getStaticPropertyName(callee);
 
   const hasKindMismatch = astInfo.kind && node.kind !== astInfo.kind;
-  const hasOperatorMismatch =
-    astInfo.operator && node.operator !== astInfo.operator;
-  const hasCalleeMismatch =
-    astInfo.callee && (!callee || callee.name !== astInfo.callee);
+  const hasOperatorMismatch = astInfo.operator && node.operator !== astInfo.operator;
+  const hasCalleeMismatch = astInfo.callee && (!callee || callee.name !== astInfo.callee);
 
   const hasCalleeObject = calleeObjectName === astInfo.object;
-  const hasCalleeIdentifier =
-    callee?.type === "Identifier" && callee?.name === astInfo.object;
-  const hasPropertyMismatch =
-    astInfo.property && calleePropertyName !== astInfo.property;
+  const hasCalleeIdentifier = callee?.type === "Identifier" && callee?.name === astInfo.object;
+  const hasPropertyMismatch = astInfo.property && calleePropertyName !== astInfo.property;
   const hasPropertyMatch = calleePropertyName === astInfo.property;
   const shouldExclude = astInfo.excludeObjects?.includes(calleeObjectName);
 
@@ -229,50 +152,38 @@ function checkMap(node, astInfo) {
     needsObjectAndProperty && !(hasCalleeObject && hasPropertyMatch);
 
   const hasObjectPropertyMismatch =
-    !needsObjectAndProperty &&
-    astInfo.object &&
-    hasCalleeObject &&
-    hasPropertyMismatch;
-  const hasObjectButNoMatch =
-    !needsObjectAndProperty &&
-    astInfo.object &&
-    !hasCalleeObject &&
-    !hasCalleeIdentifier;
-  const hasPropertyWithoutMatch =
-    astInfo.property && !astInfo.object && !hasPropertyMatch;
+    !needsObjectAndProperty && astInfo.object && hasCalleeObject && hasPropertyMismatch;
+  const needsObjectOnly = !needsObjectAndProperty && astInfo.object;
+  const hasNoCalleeObjectMatch = !hasCalleeObject && !hasCalleeIdentifier;
+  const hasObjectButNoMatch = needsObjectOnly && hasNoCalleeObjectMatch;
+  const hasPropertyWithoutMatch = astInfo.property && !astInfo.object && !hasPropertyMatch;
   const hasPropertyWithExclusion =
     astInfo.property && !astInfo.object && hasPropertyMatch && shouldExclude;
 
-  const hasOptionsCauseMismatch =
-    astInfo.hasOptionsCause && !hasOptionsCause(node);
+  const hasOptionsCauseMismatch = astInfo.hasOptionsCause && !hasOptionsCause(node);
 
   const callerType = calleeObject?.type;
-  const hasExcludedCallerType =
-    astInfo.excludeCallerTypes?.includes(callerType);
+  const hasExcludedCallerType = astInfo.excludeCallerTypes?.includes(callerType);
 
-  const hasNumericArgMismatch =
-    astInfo.requireNumericArg && !hasNumericArgument(node);
+  const hasNumericArgMismatch = astInfo.requireNumericArg && !hasNumericArgument(node);
 
-  const hasArrayLikeCallMismatch =
-    astInfo.requireArrayLikeCall && !isArrayLikeCall(node);
+  const hasArrayLikeCallMismatch = astInfo.requireArrayLikeCall && !isArrayLikeCall(node);
 
-  const hasSetLikeCallMismatch =
-    astInfo.requireSetLikeCall && !isSetLikeCall(node);
+  const hasSetLikeCallMismatch = astInfo.requireSetLikeCall && !isSetLikeCall(node);
 
-  const hasMismatch =
-    hasKindMismatch ||
-    hasOperatorMismatch ||
-    hasCalleeMismatch ||
-    hasObjectPropertyMismatch ||
+  const mismatchChecks = [
+    hasKindMismatch || hasOperatorMismatch || hasCalleeMismatch || hasObjectPropertyMismatch,
     hasObjectButNoMatch ||
-    hasPropertyWithoutMatch ||
-    hasPropertyWithExclusion ||
-    hasObjectAndPropertyMismatch ||
+      hasPropertyWithoutMatch ||
+      hasPropertyWithExclusion ||
+      hasObjectAndPropertyMismatch,
     hasOptionsCauseMismatch ||
-    hasExcludedCallerType ||
-    hasNumericArgMismatch ||
-    hasArrayLikeCallMismatch ||
-    hasSetLikeCallMismatch;
+      hasExcludedCallerType ||
+      hasNumericArgMismatch ||
+      hasArrayLikeCallMismatch,
+    hasSetLikeCallMismatch,
+  ];
+  const hasMismatch = mismatchChecks.includes(true);
 
   if (hasMismatch) return false;
 
@@ -281,4 +192,5 @@ function checkMap(node, astInfo) {
 
 module.exports = {
   checkMap,
+  getStaticPropertyName,
 };