eslint 8.22.0 → 8.33.0

package/lib/rules/array-callback-return.js

@@ -16,7 +16,7 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u;
-const TARGET_METHODS = /^(?:every|filter|find(?:Index)?|flatMap|forEach|map|reduce(?:Right)?|some|sort)$/u;
+const TARGET_METHODS = /^(?:every|filter|find(?:Last)?(?:Index)?|flatMap|forEach|map|reduce(?:Right)?|some|sort)$/u;
 
 /**
  * Checks a given code path segment is reachable.
@@ -125,7 +125,7 @@ function getArrayMethodName(node) {
         }
     }
 
-    /* istanbul ignore next: unreachable */
+    /* c8 ignore next */
     return null;
 }
 

package/lib/rules/comma-dangle.js

@@ -50,7 +50,7 @@ function normalizeOptions(optionValue, ecmaVersion) {
             objects: optionValue,
             imports: optionValue,
             exports: optionValue,
-            functions: (!ecmaVersion || ecmaVersion < 8) ? "ignore" : optionValue
+            functions: ecmaVersion < 2017 ? "ignore" : optionValue
         };
     }
     if (typeof optionValue === "object" && optionValue !== null) {
@@ -134,7 +134,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = normalizeOptions(context.options[0], context.parserOptions.ecmaVersion);
+        const options = normalizeOptions(context.options[0], context.languageOptions.ecmaVersion);
 
         const sourceCode = context.getSourceCode();
 
@@ -346,7 +346,7 @@ module.exports = {
             "always-multiline": forceTrailingCommaIfMultiline,
             "only-multiline": allowTrailingCommaIfMultiline,
             never: forbidTrailingComma,
-            ignore: () => {}
+            ignore() {}
         };
 
         return {

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/func-name-matching.js

@@ -44,7 +44,7 @@ function isModuleExports(pattern) {
  * @returns {boolean} True if the string is a valid identifier
  */
 function isIdentifier(name, ecmaVersion) {
-    if (ecmaVersion >= 6) {
+    if (ecmaVersion >= 2015) {
         return esutils.keyword.isIdentifierES6(name);
     }
     return esutils.keyword.isIdentifierES5(name);
@@ -104,7 +104,7 @@ module.exports = {
         const nameMatches = typeof context.options[0] === "string" ? context.options[0] : "always";
         const considerPropertyDescriptor = options.considerPropertyDescriptor;
         const includeModuleExports = options.includeCommonJSModuleExports;
-        const ecmaVersion = context.parserOptions && context.parserOptions.ecmaVersion ? context.parserOptions.ecmaVersion : 5;
+        const ecmaVersion = context.languageOptions.ecmaVersion;
 
         /**
          * Check whether node is a certain CallExpression.

package/lib/rules/getter-return.js

@@ -112,18 +112,24 @@ module.exports = {
                 }
                 if (parent.type === "Property" && astUtils.getStaticPropertyName(parent) === "get" && parent.parent.type === "ObjectExpression") {
 
-                    // Object.defineProperty()
-                    if (parent.parent.parent.type === "CallExpression" &&
-                        astUtils.getStaticPropertyName(parent.parent.parent.callee) === "defineProperty") {
-                        return true;
+                    // Object.defineProperty() or Reflect.defineProperty()
+                    if (parent.parent.parent.type === "CallExpression") {
+                        const callNode = parent.parent.parent.callee;
+
+                        if (astUtils.isSpecificMemberAccess(callNode, "Object", "defineProperty") ||
+                            astUtils.isSpecificMemberAccess(callNode, "Reflect", "defineProperty")) {
+                            return true;
+                        }
                     }
 
-                    // Object.defineProperties()
+                    // Object.defineProperties() or Object.create()
                     if (parent.parent.parent.type === "Property" &&
                         parent.parent.parent.parent.type === "ObjectExpression" &&
-                        parent.parent.parent.parent.parent.type === "CallExpression" &&
-                        astUtils.getStaticPropertyName(parent.parent.parent.parent.parent.callee) === "defineProperties") {
-                        return true;
+                        parent.parent.parent.parent.parent.type === "CallExpression") {
+                        const callNode = parent.parent.parent.parent.parent.callee;
+
+                        return astUtils.isSpecificMemberAccess(callNode, "Object", "defineProperties") ||
+                               astUtils.isSpecificMemberAccess(callNode, "Object", "create");
                     }
                 }
             }

package/lib/rules/global-require.js

@@ -28,10 +28,11 @@ function findReference(scope, node) {
     const references = scope.references.filter(reference => reference.identifier.range[0] === node.range[0] &&
             reference.identifier.range[1] === node.range[1]);
 
-    /* istanbul ignore else: correctly returns null */
     if (references.length === 1) {
         return references[0];
     }
+
+    /* c8 ignore next */
     return null;
 
 }

package/lib/rules/id-length.js

@@ -6,6 +6,45 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+const GraphemeSplitter = require("grapheme-splitter");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks if the string given as argument is ASCII or not.
+ * @param {string} value A string that you want to know if it is ASCII or not.
+ * @returns {boolean} `true` if `value` is ASCII string.
+ */
+function isASCII(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    return /^[\u0020-\u007f]*$/u.test(value);
+}
+
+/** @type {GraphemeSplitter | undefined} */
+let splitter;
+
+/**
+ * Gets the length of the string. If the string is not in ASCII, counts graphemes.
+ * @param {string} value A string that you want to get the length.
+ * @returns {number} The length of `value`.
+ */
+function getStringLength(value) {
+    if (isASCII(value)) {
+        return value.length;
+    }
+    if (!splitter) {
+        splitter = new GraphemeSplitter();
+    }
+    return splitter.countGraphemes(value);
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -130,8 +169,10 @@ module.exports = {
                 const name = node.name;
                 const parent = node.parent;
 
-                const isShort = name.length < minLength;
-                const isLong = name.length > maxLength;
+                const nameLength = getStringLength(name);
+
+                const isShort = nameLength < minLength;
+                const isLong = nameLength > maxLength;
 
                 if (!(isShort || isLong) || exceptions.has(name) || matchesExceptionPattern(name)) {
                     return; // Nothing to report

package/lib/rules/indent-legacy.js

@@ -18,8 +18,8 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
-
-/* istanbul ignore next: this rule has known coverage issues, but it's deprecated and shouldn't be updated in the future anyway. */
+// this rule has known coverage issues, but it's deprecated and shouldn't be updated in the future anyway.
+/* c8 ignore next */
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
@@ -212,10 +212,10 @@ module.exports = {
             if (context.options[0] === "tab") {
                 indentSize = 1;
                 indentType = "tab";
-            } else /* istanbul ignore else : this will be caught by options validation */ if (typeof context.options[0] === "number") {
+            } else /* c8 ignore start */ if (typeof context.options[0] === "number") {
                 indentSize = context.options[0];
                 indentType = "space";
-            }
+            }/* c8 ignore stop */
 
             if (context.options[1]) {
                 const opts = context.options[1];

package/lib/rules/indent.js

@@ -12,7 +12,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const createTree = require("functional-red-black-tree");
+const { OrderedMap } = require("js-sdsl");
 
 const astUtils = require("./utils/ast-utils");
 
@@ -135,7 +135,8 @@ class BinarySearchTree {
      * Creates an empty tree
      */
     constructor() {
-        this._rbTree = createTree();
+        this._orderedMap = new OrderedMap();
+        this._orderedMapEnd = this._orderedMap.end();
     }
 
     /**
@@ -145,13 +146,7 @@ class BinarySearchTree {
      * @returns {void}
      */
     insert(key, value) {
-        const iterator = this._rbTree.find(key);
-
-        if (iterator.valid) {
-            this._rbTree = iterator.update(value);
-        } else {
-            this._rbTree = this._rbTree.insert(key, value);
-        }
+        this._orderedMap.setElement(key, value);
     }
 
     /**
@@ -160,9 +155,13 @@ class BinarySearchTree {
      * @returns {{key: number, value: *}|null} The found entry, or null if no such entry exists.
      */
     findLe(key) {
-        const iterator = this._rbTree.le(key);
+        const iterator = this._orderedMap.reverseLowerBound(key);
 
-        return iterator && { key: iterator.key, value: iterator.value };
+        if (iterator.equals(this._orderedMapEnd)) {
+            return {};
+        }
+
+        return { key: iterator.pointer[0], value: iterator.pointer[1] };
     }
 
     /**
@@ -177,11 +176,20 @@ class BinarySearchTree {
         if (start === end) {
             return;
         }
-        const iterator = this._rbTree.ge(start);
+        const iterator = this._orderedMap.lowerBound(start);
 
-        while (iterator.valid && iterator.key < end) {
-            this._rbTree = this._rbTree.remove(iterator.key);
-            iterator.next();
+        if (iterator.equals(this._orderedMapEnd)) {
+            return;
+        }
+
+        if (end > this._orderedMap.back()[0]) {
+            while (!iterator.equals(this._orderedMapEnd)) {
+                this._orderedMap.eraseElementByIterator(iterator);
+            }
+        } else {
+            while (iterator.pointer[0] < end) {
+                this._orderedMap.eraseElementByIterator(iterator);
+            }
         }
     }
 }

package/lib/rules/index.js

@@ -72,6 +72,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "lines-around-comment": () => require("./lines-around-comment"),
     "lines-around-directive": () => require("./lines-around-directive"),
     "lines-between-class-members": () => require("./lines-between-class-members"),
+    "logical-assignment-operators": () => require("./logical-assignment-operators"),
     "max-classes-per-file": () => require("./max-classes-per-file"),
     "max-depth": () => require("./max-depth"),
     "max-len": () => require("./max-len"),
@@ -122,6 +123,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "no-empty-character-class": () => require("./no-empty-character-class"),
     "no-empty-function": () => require("./no-empty-function"),
     "no-empty-pattern": () => require("./no-empty-pattern"),
+    "no-empty-static-block": () => require("./no-empty-static-block"),
     "no-eq-null": () => require("./no-eq-null"),
     "no-eval": () => require("./no-eval"),
     "no-ex-assign": () => require("./no-ex-assign"),
@@ -166,6 +168,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "no-nested-ternary": () => require("./no-nested-ternary"),
     "no-new": () => require("./no-new"),
     "no-new-func": () => require("./no-new-func"),
+    "no-new-native-nonconstructor": () => require("./no-new-native-nonconstructor"),
     "no-new-object": () => require("./no-new-object"),
     "no-new-require": () => require("./no-new-require"),
     "no-new-symbol": () => require("./no-new-symbol"),

package/lib/rules/key-spacing.js

@@ -334,6 +334,53 @@ 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"
+            );
+        }
+
+        /**
+         * Starting from the given node (a property.key node here) looks forward
+         * until it finds the colon punctuator and returns it.
+         * @param {ASTNode} node The node to start looking from.
+         * @returns {ASTNode} The colon punctuator.
+         */
+        function getNextColon(node) {
+            return sourceCode.getTokenAfter(node, astUtils.isColonToken);
+        }
+
+        /**
+         * Starting from the given node (a property.key node here) looks forward
+         * until it finds the last token before a colon punctuator and returns it.
+         * @param {ASTNode} node The node to start looking from.
+         * @returns {ASTNode} The last token before a colon punctuator.
+         */
+        function getLastTokenBeforeColon(node) {
+            const colonToken = getNextColon(node);
+
+            return sourceCode.getTokenBefore(colonToken);
+        }
+
+        /**
+         * Starting from the given node (a property.key node here) looks forward
+         * until it finds the first token after a colon punctuator and returns it.
+         * @param {ASTNode} node The node to start looking from.
+         * @returns {ASTNode} The first token after a colon punctuator.
+         */
+        function getFirstTokenAfterColon(node) {
+            const colonToken = getNextColon(node);
+
+            return sourceCode.getTokenAfter(colonToken);
+        }
+
         /**
          * 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 +389,9 @@ module.exports = {
          */
         function continuesPropertyGroup(lastMember, candidate) {
             const groupEndLine = lastMember.loc.start.line,
-                candidateStartLine = candidate.loc.start.line;
+                candidateValueStartLine = (isKeyValueProperty(candidate) ? getFirstTokenAfterColon(candidate.key) : candidate).loc.start.line;
 
-            if (candidateStartLine - groupEndLine <= 1) {
+            if (candidateValueStartLine - groupEndLine <= 1) {
                 return true;
             }
 
@@ -358,7 +405,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,41 +418,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.
-         * @param {ASTNode} node The node to start looking from.
-         * @returns {ASTNode} The last token before a colon punctuator.
-         */
-        function getLastTokenBeforeColon(node) {
-            const colonToken = sourceCode.getTokenAfter(node, astUtils.isColonToken);
-
-            return sourceCode.getTokenBefore(colonToken);
-        }
-
-        /**
-         * Starting from the given a node (a property.key node here) looks forward
-         * until it finds the colon punctuator and returns it.
-         * @param {ASTNode} node The node to start looking from.
-         * @returns {ASTNode} The colon punctuator.
-         */
-        function getNextColon(node) {
-            return sourceCode.getTokenAfter(node, astUtils.isColonToken);
-        }
-
         /**
          * Gets an object literal property's key as the identifier name or string value.
          * @param {ASTNode} property Property node whose key to retrieve.

package/lib/rules/lines-around-comment.js

@@ -15,7 +15,7 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 /**
- * Return an array with with any line numbers that are empty.
+ * Return an array with any line numbers that are empty.
  * @param {Array} lines An array of each line of the file.
  * @returns {Array} An array of line numbers.
  */
@@ -29,7 +29,7 @@ function getEmptyLineNums(lines) {
 }
 
 /**
- * Return an array with with any line numbers that contain comments.
+ * Return an array with any line numbers that contain comments.
  * @param {Array} comments An array of comment tokens.
  * @returns {Array} An array of line numbers.
  */