es-check 9.6.1 → 9.6.3

package/lib/constants/es-features/12.js

@@ -27,6 +27,7 @@ const ES12_FEATURES = {
     example: "Promise.any(promises)",
     astInfo: {
       nodeType: "CallExpression",
+      object: "Promise",
       property: "any",
     },
   },

package/lib/constants/es-features/13.js

@@ -48,6 +48,7 @@ const ES13_FEATURES = {
       property: "at",
       excludeCallerTypes: ["ObjectExpression"],
       requireNumericArg: true,
+      requireArrayLikeCall: true,
     },
   },
   ObjectHasOwn: {

package/lib/constants/es-features/16.js

@@ -43,6 +43,7 @@ const ES16_FEATURES = {
     astInfo: {
       nodeType: "CallExpression",
       property: "union",
+      requireSetLikeCall: true,
     },
   },
   SetIntersection: {
@@ -51,6 +52,7 @@ const ES16_FEATURES = {
     astInfo: {
       nodeType: "CallExpression",
       property: "intersection",
+      requireSetLikeCall: true,
     },
   },
   SetDifference: {
@@ -59,6 +61,7 @@ const ES16_FEATURES = {
     astInfo: {
       nodeType: "CallExpression",
       property: "difference",
+      requireSetLikeCall: true,
     },
   },
   SetSymmetricDifference: {
@@ -67,6 +70,7 @@ const ES16_FEATURES = {
     astInfo: {
       nodeType: "CallExpression",
       property: "symmetricDifference",
+      requireSetLikeCall: true,
     },
   },
   SetIsSubsetOf: {
@@ -75,6 +79,7 @@ const ES16_FEATURES = {
     astInfo: {
       nodeType: "CallExpression",
       property: "isSubsetOf",
+      requireSetLikeCall: true,
     },
   },
   SetIsSupersetOf: {
@@ -83,6 +88,7 @@ const ES16_FEATURES = {
     astInfo: {
       nodeType: "CallExpression",
       property: "isSupersetOf",
+      requireSetLikeCall: true,
     },
   },
   SetIsDisjointFrom: {
@@ -91,6 +97,7 @@ const ES16_FEATURES = {
     astInfo: {
       nodeType: "CallExpression",
       property: "isDisjointFrom",
+      requireSetLikeCall: true,
     },
   },
   Float16Array: {

package/lib/helpers/ast.js

@@ -32,6 +32,177 @@ function hasNumericArgument(node) {
   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";
+}
+
+function isArrayLikeIdentifier(calleeObject) {
+  const isIdentifier = calleeObject.type === "Identifier";
+  if (!isIdentifier) return false;
+
+  const objectName = calleeObject.name.toLowerCase();
+
+  const isCommonNonArrayName = COMMON_NON_ARRAY_NAMES.has(objectName);
+  if (isCommonNonArrayName) return false;
+
+  return ARRAY_LIKE_NAMES.has(objectName);
+}
+
+function isArrayConstructorCall(calleeObject) {
+  const isCallExpression = calleeObject.type === "CallExpression";
+  if (!isCallExpression) return false;
+
+  const innerCallee = calleeObject.callee;
+  const isIdentifierCallee = innerCallee?.type === "Identifier";
+  const isMemberExpressionCallee = innerCallee?.type === "MemberExpression";
+
+  if (isIdentifierCallee) {
+    const functionName = innerCallee.name;
+    return ARRAY_CONSTRUCTOR_FUNCTIONS.has(functionName);
+  }
+
+  if (isMemberExpressionCallee) {
+    const innerProperty = innerCallee.property;
+    const hasPropertyName = innerProperty?.name;
+    const isArrayMethod =
+      hasPropertyName && ARRAY_METHODS.has(innerProperty.name);
+    return isArrayMethod;
+  }
+
+  return false;
+}
+
+function isArrayLikeCall(node) {
+  const callee = node.callee;
+  const calleeObject = callee?.object;
+  const hasCalleeObject = calleeObject != null;
+
+  if (!hasCalleeObject) return false;
+
+  const isArrayExpr = isArrayExpression(calleeObject);
+  const isArrayIdent = isArrayLikeIdentifier(calleeObject);
+  const isArrayConstr = isArrayConstructorCall(calleeObject);
+  const isArray = isArrayExpr || isArrayIdent || isArrayConstr;
+
+  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"
+  ) {
+    return true;
+  }
+  return false;
+}
+
+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")
+  );
+}
+
+function isSetLikeCall(node) {
+  const calleeObject = node.callee?.object;
+  if (!calleeObject) return false;
+
+  return (
+    isSetConstructorCall(calleeObject) || isSetLikeIdentifier(calleeObject)
+  );
+}
+
 function checkMap(node, astInfo) {
   const callee = node.callee;
   const calleeObject = callee?.object;
@@ -82,6 +253,12 @@ function checkMap(node, astInfo) {
   const hasNumericArgMismatch =
     astInfo.requireNumericArg && !hasNumericArgument(node);
 
+  const hasArrayLikeCallMismatch =
+    astInfo.requireArrayLikeCall && !isArrayLikeCall(node);
+
+  const hasSetLikeCallMismatch =
+    astInfo.requireSetLikeCall && !isSetLikeCall(node);
+
   const hasMismatch =
     hasKindMismatch ||
     hasOperatorMismatch ||
@@ -93,7 +270,9 @@ function checkMap(node, astInfo) {
     hasObjectAndPropertyMismatch ||
     hasOptionsCauseMismatch ||
     hasExcludedCallerType ||
-    hasNumericArgMismatch;
+    hasNumericArgMismatch ||
+    hasArrayLikeCallMismatch ||
+    hasSetLikeCallMismatch;
 
   if (hasMismatch) return false;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-check",
-  "version": "9.6.1",
+  "version": "9.6.3",
   "description": "Checks the ECMAScript version of .js glob against a specified version of ECMAScript with a shell command",
   "main": "lib/index.js",
   "license": "MIT",