es-check 9.7.1 → 9.8.0

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

@@ -12,6 +12,7 @@ const { ES16_FEATURES } = require("./16");
 const { ES17_FEATURES } = require("./17");
 const { ES_GLOBAL_MIN_VERSION, ES_GLOBALS_SOURCE } = require("./globals");
 const { POLYFILL_PATTERNS, IMPORT_PATTERNS, FEATURE_TO_POLYFILL_MAP } = require("./polyfills");
+const { FEATURE_BROWSER_SUPPORT } = require("./browserSupport");
 
 const ES_FEATURES = Object.assign(
   {},
@@ -36,4 +37,5 @@ module.exports = {
   POLYFILL_PATTERNS,
   IMPORT_PATTERNS,
   FEATURE_TO_POLYFILL_MAP,
+  FEATURE_BROWSER_SUPPORT,
 };

package/lib/constants/versions.js

@@ -225,10 +225,28 @@ const VERSION_ORDER = [
 
 const LATEST_PARSER_VERSION = 2026;
 
+const BROWSERSLIST_TO_BCD = {
+  and_chr: "chrome_android",
+  and_ff: "firefox_android",
+  android: "webview_android",
+  chrome: "chrome",
+  deno: "deno",
+  edge: "edge",
+  firefox: "firefox",
+  ie: "ie",
+  ios_saf: "safari_ios",
+  node: "nodejs",
+  op_mob: "opera_android",
+  opera: "opera",
+  safari: "safari",
+  samsung: "samsunginternet_android",
+};
+
 module.exports = {
   ECMA_VERSION_MAP,
   ECMA_VERSION_TO_NUMBER,
   BROWSER_TO_ES_VERSION,
+  BROWSERSLIST_TO_BCD,
   JS_VERSIONS,
   VERSION_ORDER,
   LATEST_PARSER_VERSION,

package/lib/detectFeatures.js

@@ -7,6 +7,7 @@ const {
 const { ES_GLOBAL_MIN_VERSION } = require("./constants/es-features/globals");
 const { POLYFILLABLE_FEATURES, CORE_JS_POLYFILLABLE } = require("./constants/polyfillableFeatures");
 const { detectFeaturesFromAST } = require("./helpers/astDetector");
+const { getUnsupportedBrowsers, formatFeatureWithBrowsers } = require("./helpers/browserSupport");
 
 function getPolyfillableFeatures(library) {
   if (!library) {
@@ -50,7 +51,7 @@ const detectPolyfills = (
 };
 
 const detectFeatures = (code, ecmaVersion, sourceType, ignoreList = new Set(), options = {}) => {
-  const { checkForPolyfills, ast, ignorePolyfillable } = options;
+  const { checkForPolyfills, ast, ignorePolyfillable, targetBrowsers } = options;
 
   if (!ast) {
     const error = new Error("AST is required for feature detection");
@@ -65,17 +66,26 @@ const detectFeatures = (code, ecmaVersion, sourceType, ignoreList = new Set(), o
 
   const polyfillableSet = ignorePolyfillable ? getPolyfillableFeatures(ignorePolyfillable) : null;
 
+  const browserDetails = {};
+
   function isUnsupportedFeature(name, minVersion) {
     const wasFound = foundFeatures[name];
+    if (!wasFound) return false;
+
+    const unsupportedBrowsers = getUnsupportedBrowsers(name, targetBrowsers);
+    const lacksBrowserSupport = unsupportedBrowsers.length > 0;
     const requiresHigherVersion = minVersion > ecmaVersion;
+    const shouldReport = requiresHigherVersion || lacksBrowserSupport;
+    if (!shouldReport) return false;
+
     const isIgnored = ignoreList.has(name);
     const isPolyfilled = checkForPolyfills && polyfills.has(name);
     const isPolyfillableIgnored = polyfillableSet && polyfillableSet.has(name);
-
     const isAllowed = isIgnored || isPolyfilled || isPolyfillableIgnored;
-    const shouldReport = wasFound && requiresHigherVersion;
-    if (!shouldReport) return false;
-    return !isAllowed;
+    if (isAllowed) return false;
+
+    if (lacksBrowserSupport) browserDetails[name] = unsupportedBrowsers;
+    return true;
   }
 
   const unsupportedStandardFeatures = Object.entries(ES_FEATURES)
@@ -90,12 +100,17 @@ const detectFeatures = (code, ecmaVersion, sourceType, ignoreList = new Set(), o
   const unsupportedFeatures = unsupportedStandardFeatures.concat(unsupportedGlobalFeatures);
 
   if (unsupportedFeatures.length > 0) {
-    const error = new Error(
-      `Unsupported features detected: ${unsupportedFeatures.join(", ")}. ` +
-        `These require a higher ES version than ${ecmaVersion}.`,
-    );
+    const hasBrowserDetails = Object.keys(browserDetails).length > 0;
+    const featureList = unsupportedFeatures
+      .map((name) => formatFeatureWithBrowsers(name, browserDetails[name]))
+      .join(", ");
+    const reason = hasBrowserDetails
+      ? `These require a higher ES version than ${ecmaVersion} or are not supported by the target browsers.`
+      : `These require a higher ES version than ${ecmaVersion}.`;
+    const error = new Error(`Unsupported features detected: ${featureList}. ${reason}`);
     error.type = "ES-Check";
     error.features = unsupportedFeatures;
+    error.browserDetails = browserDetails;
     error.ecmaVersion = ecmaVersion;
     throw error;
   }
@@ -103,6 +118,7 @@ const detectFeatures = (code, ecmaVersion, sourceType, ignoreList = new Set(), o
   return {
     foundFeatures,
     unsupportedFeatures,
+    browserDetails,
   };
 };
 

package/lib/helpers/astDetector.js

@@ -1609,16 +1609,49 @@ function getTypeofComparisonGuardBranch(comparison) {
 
 function getTypeofComparison(node) {
   if (node.type !== "BinaryExpression") return null;
-  if (!isTypeofComparisonOperator(node.operator)) return null;
 
   const leftComparison = getTypeofComparisonSide(node.left, node.right);
   if (leftComparison) {
-    return Object.assign({}, leftComparison, { operator: node.operator });
+    return normalizeTypeofComparison(leftComparison, node.operator);
   }
 
   const rightComparison = getTypeofComparisonSide(node.right, node.left);
-  if (!rightComparison) return null;
-  return Object.assign({}, rightComparison, { operator: node.operator });
+  if (rightComparison) {
+    return normalizeTypeofComparison(rightComparison, node.operator, true);
+  }
+  return getBooleanTypeofComparison(node);
+}
+
+function getBooleanTypeofComparison(node) {
+  if (!isTypeofComparisonOperator(node.operator)) return null;
+
+  const isLeftBoolean = typeof node.left.value === "boolean";
+  const valueNode = isLeftBoolean ? node.left : node.right;
+  const expression = isLeftBoolean ? node.right : node.left;
+  const isBoolean = valueNode.type === "Literal" && typeof valueNode.value === "boolean";
+  if (!isBoolean) return null;
+
+  const comparison = getTypeofComparison(expression);
+  if (!comparison) return null;
+  const isEqual = node.operator === "===" || node.operator === "==";
+  const preservesPolarity = isEqual === valueNode.value;
+  const guardedBranch = getTypeofComparisonGuardBranch(comparison) === preservesPolarity;
+  const operator = guardedBranch ? "!==" : "===";
+  return { name: comparison.name, value: "undefined", operator };
+}
+
+function normalizeTypeofComparison(comparison, operator, isReversed = false) {
+  if (isTypeofComparisonOperator(operator)) {
+    return Object.assign({}, comparison, { operator });
+  }
+
+  const isRelational = operator === "<" || operator === ">";
+  const isMinifiedGuard = isRelational && comparison.value === "u";
+  if (!isMinifiedGuard) return null;
+
+  const isUndefined = (operator === ">") !== isReversed;
+  const normalizedOperator = isUndefined ? "===" : "!==";
+  return Object.assign({}, comparison, { value: "undefined", operator: normalizedOperator });
 }
 
 function isTypeofComparisonOperator(operator) {
@@ -1666,6 +1699,7 @@ function isFalseLiteral(node) {
 }
 
 function shouldSkipBranchGuard(node, branchValue) {
+  if (node.type === "BinaryExpression") return true;
   const isLogical = node.type === "LogicalExpression";
   if (!isLogical) return false;
 

package/lib/helpers/browserSupport.js

@@ -0,0 +1,89 @@
+const { FEATURE_BROWSER_SUPPORT } = require("../constants/es-features/browserSupport");
+
+function compareVersions(a, b) {
+  const aParts = String(a).split(".").map(Number);
+  const bParts = String(b).split(".").map(Number);
+  const length = Math.max(aParts.length, bParts.length);
+
+  let index = 0;
+  while (index < length) {
+    const diff = (aParts[index] || 0) - (bParts[index] || 0);
+    if (diff !== 0) return diff;
+    index += 1;
+  }
+
+  return 0;
+}
+
+function isVersionSupported(targetVersion, versionAdded) {
+  const isSupportedWithoutVersion = versionAdded === true;
+  if (isSupportedWithoutVersion) return true;
+
+  const isNeverSupported = versionAdded === false;
+  if (isNeverSupported) return false;
+
+  return compareVersions(targetVersion, versionAdded) >= 0;
+}
+
+function keepLowestVersionPerBrowser(browsers) {
+  const lowestByName = new Map();
+
+  browsers.forEach((browser) => {
+    const current = lowestByName.get(browser.name);
+    const isLower = !current || compareVersions(browser.version, current.version) < 0;
+    if (isLower) lowestByName.set(browser.name, browser);
+  });
+
+  return Array.from(lowestByName.values());
+}
+
+function getUnsupportedBrowsers(
+  featureName,
+  targetBrowsers,
+  browserSupport = FEATURE_BROWSER_SUPPORT,
+) {
+  const support = browserSupport[featureName];
+  const hasNoTargets = !targetBrowsers || targetBrowsers.length === 0;
+  const hasNoData = !support || hasNoTargets;
+  if (hasNoData) return [];
+
+  const unsupported = targetBrowsers.filter((browser) => {
+    const versionAdded = support[browser.name];
+    const hasBrowserData = versionAdded !== undefined;
+    if (!hasBrowserData) return false;
+    return !isVersionSupported(browser.version, versionAdded);
+  });
+
+  return keepLowestVersionPerBrowser(unsupported).map((browser) => ({
+    name: browser.name,
+    version: browser.version,
+    requiredVersion: support[browser.name],
+  }));
+}
+
+function formatBrowserRequirement({ name, version, requiredVersion }) {
+  const isNeverSupported = requiredVersion === false;
+  if (isNeverSupported) return `${name} ${version} has no support`;
+  return `${name} ${version} requires ${requiredVersion}`;
+}
+
+function formatFeatureWithBrowsers(featureName, unsupportedBrowsers) {
+  const hasNoBrowsers = !unsupportedBrowsers || unsupportedBrowsers.length === 0;
+  if (hasNoBrowsers) return featureName;
+
+  const requirements = unsupportedBrowsers.map(formatBrowserRequirement).join(", ");
+  return `${featureName} (${requirements})`;
+}
+
+function formatTargetBrowsers(targetBrowsers) {
+  return targetBrowsers.map((browser) => `${browser.name} ${browser.version}`).join(", ");
+}
+
+module.exports = {
+  compareVersions,
+  isVersionSupported,
+  getUnsupportedBrowsers,
+  formatBrowserRequirement,
+  formatFeatureWithBrowsers,
+  formatTargetBrowsers,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-check",
-  "version": "9.7.1",
+  "version": "9.8.0",
   "description": "Checks the ECMAScript version of .js glob against a specified version of ECMAScript with a shell command",
   "keywords": [
     "check for es6",
@@ -75,9 +75,10 @@
     "release:tag:dry": "node scripts/release-tag.mjs --dry-run",
     "release:dry": "release-it --dry-run --no-git.requireUpstream",
     "report:coverage": "mkdir -p coverage && node tests/scripts/test-runner.js unit --coverage --reporter=lcov --reporter-destination=coverage/lcov.info",
-    "scripts:generate": "pnpm run scripts:generate:requirements && pnpm run scripts:generate:polyfills",
+    "scripts:generate": "pnpm run scripts:generate:requirements && pnpm run scripts:generate:polyfills && pnpm run scripts:generate:browser-support",
     "scripts:generate:requirements": "node scripts/generate/requirements/parser.mjs",
     "scripts:generate:polyfills": "node scripts/generate/polyfills/core.mjs",
+    "scripts:generate:browser-support": "node scripts/generate/browser-support/index.mjs",
     "test": "node tests/scripts/test-runner.js unit && npm run test:e2e",
     "test:unit": "node tests/scripts/test-runner.js unit",
     "test:unit:verbose": "node tests/scripts/test-runner.js unit --verbose",
@@ -100,7 +101,7 @@
     "fast-glob": "^3.3.3"
   },
   "devDependencies": {
-    "@mdn/browser-compat-data": "^8.1.0",
+    "@mdn/browser-compat-data": "^8.1.2",
     "codependence": "1.0.15",
     "core-js-compat": "^3.50.0",
     "oxfmt": "^0.67.0",