eslint 8.27.0 → 8.28.0

package/lib/eslint/eslint-helpers.js

@@ -26,6 +26,7 @@ const isPathInside = require("is-path-inside");
 
 const doFsWalk = util.promisify(fswalk.walk);
 const Minimatch = minimatch.Minimatch;
+const MINIMATCH_OPTIONS = { dot: true };
 
 //-----------------------------------------------------------------------------
 // Types
@@ -76,7 +77,7 @@ class UnmatchedSearchPatternsError extends Error {
     constructor({ basePath, unmatchedPatterns, patterns, rawPatterns }) {
         super(`No files matching '${rawPatterns}' in '${basePath}' were found.`);
         this.basePath = basePath;
-        this.patternsToCheck = unmatchedPatterns;
+        this.unmatchedPatterns = unmatchedPatterns;
         this.patterns = patterns;
         this.rawPatterns = rawPatterns;
     }
@@ -158,7 +159,7 @@ function globMatch({ basePath, pattern }) {
         ? normalizeToPosix(path.relative(basePath, pattern))
         : pattern;
 
-    const matcher = new Minimatch(patternToUse);
+    const matcher = new Minimatch(patternToUse, MINIMATCH_OPTIONS);
 
     const fsWalkSettings = {
 
@@ -257,7 +258,7 @@ async function globSearch({
 
         relativeToPatterns.set(patternToUse, patterns[i]);
 
-        return new minimatch.Minimatch(patternToUse);
+        return new Minimatch(patternToUse, MINIMATCH_OPTIONS);
     });
 
     /*
@@ -337,49 +338,43 @@ async function globSearch({
 }
 
 /**
- * Checks to see if there are any ignored results for a given search. This
- * happens either when there are unmatched patterns during a search or if
- * a search returns no results.
+ * Throws an error for unmatched patterns. The error will only contain information about the first one.
+ * Checks to see if there are any ignored results for a given search.
  * @param {Object} options The options for this function.
  * @param {string} options.basePath The directory to search.
  * @param {Array<string>} options.patterns An array of glob patterns
  *      that were used in the original search.
  * @param {Array<string>} options.rawPatterns An array of glob patterns
  *      as the user inputted them. Used for errors.
- * @param {Array<string>} options.patternsToCheck An array of glob patterns
- *      to use for this check.
- * @returns {void}
- * @throws {NoFilesFoundError} If there is a pattern that doesn't match
- *      any files and `errorOnUnmatchedPattern` is true.
- * @throws {AllFilesIgnoredError} If there is a pattern that matches files
- *      when there are no ignores.
+ * @param {Array<string>} options.unmatchedPatterns A non-empty array of glob patterns
+ *      that were unmatched in the original search.
+ * @returns {void} Always throws an error.
+ * @throws {NoFilesFoundError} If the first unmatched pattern
+ *      doesn't match any files even when there are no ignores.
+ * @throws {AllFilesIgnoredError} If the first unmatched pattern
+ *      matches some files when there are no ignores.
  */
-async function checkForIgnoredResults({
+async function throwErrorForUnmatchedPatterns({
     basePath,
     patterns,
     rawPatterns,
-    patternsToCheck = patterns
+    unmatchedPatterns
 }) {
 
-    for (const pattern of patternsToCheck) {
+    const pattern = unmatchedPatterns[0];
+    const rawPattern = rawPatterns[patterns.indexOf(pattern)];
 
-        const patternHasMatch = await globMatch({
-            basePath,
-            pattern
-        });
+    const patternHasMatch = await globMatch({
+        basePath,
+        pattern
+    });
 
-        if (patternHasMatch) {
-            throw new AllFilesIgnoredError(
-                rawPatterns[patterns.indexOf(pattern)]
-            );
-        }
+    if (patternHasMatch) {
+        throw new AllFilesIgnoredError(rawPattern);
     }
 
     // if we get here there are truly no matches
-    throw new NoFilesFoundError(
-        rawPatterns[patterns.indexOf(patternsToCheck[0])],
-        true
-    );
+    throw new NoFilesFoundError(rawPattern, true);
 }
 
 /**
@@ -446,9 +441,9 @@ async function globMultiSearch({ searches, configs, errorOnUnmatchedPattern }) {
 
         if (errorOnUnmatchedPattern) {
 
-            await checkForIgnoredResults({
+            await throwErrorForUnmatchedPatterns({
                 ...currentSearch,
-                patternsToCheck: error.patternsToCheck
+                unmatchedPatterns: error.unmatchedPatterns
             });
 
         }

package/lib/rules/for-direction.js

@@ -15,7 +15,7 @@ module.exports = {
         type: "problem",
 
         docs: {
-            description: "Enforce \"for\" loop update clause moving the counter in the right direction.",
+            description: "Enforce \"for\" loop update clause moving the counter in the right direction",
             recommended: true,
             url: "https://eslint.org/docs/rules/for-direction"
         },

package/lib/rules/key-spacing.js

@@ -334,6 +334,19 @@ module.exports = {
 
         const sourceCode = context.getSourceCode();
 
+        /**
+         * Determines if the given property is key-value property.
+         * @param {ASTNode} property Property node to check.
+         * @returns {boolean} Whether the property is a key-value property.
+         */
+        function isKeyValueProperty(property) {
+            return !(
+                (property.method ||
+                property.shorthand ||
+                property.kind !== "init" || property.type !== "Property") // Could be "ExperimentalSpreadProperty" or "SpreadElement"
+            );
+        }
+
         /**
          * Checks whether a property is a member of the property group it follows.
          * @param {ASTNode} lastMember The last Property known to be in the group.
@@ -342,9 +355,9 @@ module.exports = {
          */
         function continuesPropertyGroup(lastMember, candidate) {
             const groupEndLine = lastMember.loc.start.line,
-                candidateStartLine = candidate.loc.start.line;
+                candidateValueStartLine = (isKeyValueProperty(candidate) ? candidate.value : candidate).loc.start.line;
 
-            if (candidateStartLine - groupEndLine <= 1) {
+            if (candidateValueStartLine - groupEndLine <= 1) {
                 return true;
             }
 
@@ -358,7 +371,7 @@ module.exports = {
             if (
                 leadingComments.length &&
                 leadingComments[0].loc.start.line - groupEndLine <= 1 &&
-                candidateStartLine - last(leadingComments).loc.end.line <= 1
+                candidateValueStartLine - last(leadingComments).loc.end.line <= 1
             ) {
                 for (let i = 1; i < leadingComments.length; i++) {
                     if (leadingComments[i].loc.start.line - leadingComments[i - 1].loc.end.line > 1) {
@@ -371,19 +384,6 @@ module.exports = {
             return false;
         }
 
-        /**
-         * Determines if the given property is key-value property.
-         * @param {ASTNode} property Property node to check.
-         * @returns {boolean} Whether the property is a key-value property.
-         */
-        function isKeyValueProperty(property) {
-            return !(
-                (property.method ||
-                property.shorthand ||
-                property.kind !== "init" || property.type !== "Property") // Could be "ExperimentalSpreadProperty" or "SpreadElement"
-            );
-        }
-
         /**
          * Starting from the given a node (a property.key node here) looks forward
          * until it finds the last token before a colon punctuator and returns it.

package/lib/rules/no-implicit-coercion.js

@@ -71,6 +71,24 @@ function isMultiplyByOne(node) {
     );
 }
 
+/**
+ * Checks whether the given node logically represents multiplication by a fraction of `1`.
+ * For example, `a * 1` in `a * 1 / b` is technically multiplication by `1`, but the
+ * whole expression can be logically interpreted as `a * (1 / b)` rather than `(a * 1) / b`.
+ * @param {BinaryExpression} node A BinaryExpression node to check.
+ * @param {SourceCode} sourceCode The source code object.
+ * @returns {boolean} Whether or not the node is a multiplying by a fraction of `1`.
+ */
+function isMultiplyByFractionOfOne(node, sourceCode) {
+    return node.type === "BinaryExpression" &&
+        node.operator === "*" &&
+        (node.right.type === "Literal" && node.right.value === 1) &&
+        node.parent.type === "BinaryExpression" &&
+        node.parent.operator === "/" &&
+        node.parent.left === node &&
+        !astUtils.isParenthesised(sourceCode, node);
+}
+
 /**
  * Checks whether the result of a node is numeric or not
  * @param {ASTNode} node The node to test
@@ -290,7 +308,8 @@ module.exports = {
 
                 // 1 * foo
                 operatorAllowed = options.allow.includes("*");
-                const nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && getNonNumericOperand(node);
+                const nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && !isMultiplyByFractionOfOne(node, sourceCode) &&
+                    getNonNumericOperand(node);
 
                 if (nonNumericOperand) {
                     const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;

package/lib/rules/no-magic-numbers.js

@@ -65,6 +65,10 @@ module.exports = {
                 ignoreDefaultValues: {
                     type: "boolean",
                     default: false
+                },
+                ignoreClassFieldInitialValues: {
+                    type: "boolean",
+                    default: false
                 }
             },
             additionalProperties: false
@@ -82,7 +86,8 @@ module.exports = {
             enforceConst = !!config.enforceConst,
             ignore = new Set((config.ignore || []).map(normalizeIgnoreValue)),
             ignoreArrayIndexes = !!config.ignoreArrayIndexes,
-            ignoreDefaultValues = !!config.ignoreDefaultValues;
+            ignoreDefaultValues = !!config.ignoreDefaultValues,
+            ignoreClassFieldInitialValues = !!config.ignoreClassFieldInitialValues;
 
         const okTypes = detectObjects ? [] : ["ObjectExpression", "Property", "AssignmentExpression"];
 
@@ -106,6 +111,17 @@ module.exports = {
             return parent.type === "AssignmentPattern" && parent.right === fullNumberNode;
         }
 
+        /**
+         * Returns whether the number is the initial value of a class field.
+         * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
+         * @returns {boolean} true if the number is the initial value of a class field.
+         */
+        function isClassFieldInitialValue(fullNumberNode) {
+            const parent = fullNumberNode.parent;
+
+            return parent.type === "PropertyDefinition" && parent.value === fullNumberNode;
+        }
+
         /**
          * Returns whether the given node is used as a radix within parseInt() or Number.parseInt()
          * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
@@ -194,6 +210,7 @@ module.exports = {
                 if (
                     isIgnoredValue(value) ||
                     (ignoreDefaultValues && isDefaultValue(fullNumberNode)) ||
+                    (ignoreClassFieldInitialValues && isClassFieldInitialValue(fullNumberNode)) ||
                     isParseIntRadix(fullNumberNode) ||
                     isJSXNumber(fullNumberNode) ||
                     (ignoreArrayIndexes && isArrayIndex(fullNumberNode, value))

package/lib/rules/no-obj-calls.js

@@ -16,7 +16,7 @@ const getPropertyName = require("./utils/ast-utils").getStaticPropertyName;
 // Helpers
 //------------------------------------------------------------------------------
 
-const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect"];
+const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect", "Intl"];
 
 /**
  * Returns the name of the node to report

package/lib/rules/prefer-object-spread.js

@@ -247,7 +247,7 @@ module.exports = {
 
         docs: {
             description:
-                "Disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead.",
+                "Disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead",
             recommended: false,
             url: "https://eslint.org/docs/rules/prefer-object-spread"
         },

package/lib/shared/runtime-info.js

@@ -97,7 +97,7 @@ function environment() {
      */
     function getNpmPackageVersion(pkg, { global = false } = {}) {
         const npmBinArgs = ["bin", "-g"];
-        const npmLsArgs = ["ls", "--depth=0", "--json", "eslint"];
+        const npmLsArgs = ["ls", "--depth=0", "--json", pkg];
 
         if (global) {
             npmLsArgs.push("-g");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.27.0",
+  "version": "8.28.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {