eslint 9.0.0-alpha.0 → 9.0.0-alpha.2

package/lib/rules/padded-blocks.js

@@ -84,18 +84,18 @@ module.exports = {
             options.switches = shouldHavePadding;
             options.classes = shouldHavePadding;
         } else {
-            if (Object.prototype.hasOwnProperty.call(typeOptions, "blocks")) {
+            if (Object.hasOwn(typeOptions, "blocks")) {
                 options.blocks = typeOptions.blocks === "always";
             }
-            if (Object.prototype.hasOwnProperty.call(typeOptions, "switches")) {
+            if (Object.hasOwn(typeOptions, "switches")) {
                 options.switches = typeOptions.switches === "always";
             }
-            if (Object.prototype.hasOwnProperty.call(typeOptions, "classes")) {
+            if (Object.hasOwn(typeOptions, "classes")) {
                 options.classes = typeOptions.classes === "always";
             }
         }
 
-        if (Object.prototype.hasOwnProperty.call(exceptOptions, "allowSingleLineBlocks")) {
+        if (Object.hasOwn(exceptOptions, "allowSingleLineBlocks")) {
             options.allowSingleLineBlocks = exceptOptions.allowSingleLineBlocks === true;
         }
 
@@ -277,7 +277,7 @@ module.exports = {
 
         const rule = {};
 
-        if (Object.prototype.hasOwnProperty.call(options, "switches")) {
+        if (Object.hasOwn(options, "switches")) {
             rule.SwitchStatement = function(node) {
                 if (node.cases.length === 0) {
                     return;
@@ -286,7 +286,7 @@ module.exports = {
             };
         }
 
-        if (Object.prototype.hasOwnProperty.call(options, "blocks")) {
+        if (Object.hasOwn(options, "blocks")) {
             rule.BlockStatement = function(node) {
                 if (node.body.length === 0) {
                     return;
@@ -296,7 +296,7 @@ module.exports = {
             rule.StaticBlock = rule.BlockStatement;
         }
 
-        if (Object.prototype.hasOwnProperty.call(options, "classes")) {
+        if (Object.hasOwn(options, "classes")) {
             rule.ClassBody = function(node) {
                 if (node.body.length === 0) {
                     return;

package/lib/rules/prefer-arrow-callback.js

@@ -220,7 +220,7 @@ module.exports = {
 
             // If there are below, it cannot replace with arrow functions merely.
             ThisExpression() {
-                const info = stack[stack.length - 1];
+                const info = stack.at(-1);
 
                 if (info) {
                     info.this = true;
@@ -228,7 +228,7 @@ module.exports = {
             },
 
             Super() {
-                const info = stack[stack.length - 1];
+                const info = stack.at(-1);
 
                 if (info) {
                     info.super = true;
@@ -236,7 +236,7 @@ module.exports = {
             },
 
             MetaProperty(node) {
-                const info = stack[stack.length - 1];
+                const info = stack.at(-1);
 
                 if (info && checkMetaProperty(node, "new", "target")) {
                     info.meta = true;

package/lib/rules/prefer-reflect.js

@@ -105,7 +105,7 @@ module.exports = {
             CallExpression(node) {
                 const methodName = (node.callee.property || {}).name;
                 const isReflectCall = (node.callee.object || {}).name === "Reflect";
-                const hasReflectSubstitute = Object.prototype.hasOwnProperty.call(reflectSubstitutes, methodName);
+                const hasReflectSubstitute = Object.hasOwn(reflectSubstitutes, methodName);
                 const userConfiguredException = exceptions.includes(methodName);
 
                 if (hasReflectSubstitute && !isReflectCall && !userConfiguredException) {

package/lib/rules/prefer-regex-literals.js

@@ -34,7 +34,7 @@ function isStringLiteral(node) {
  * @returns {boolean} True if the node is a regex literal.
  */
 function isRegexLiteral(node) {
-    return node.type === "Literal" && Object.prototype.hasOwnProperty.call(node, "regex");
+    return node.type === "Literal" && Object.hasOwn(node, "regex");
 }
 
 const validPrecedingTokens = new Set([

package/lib/rules/prefer-template.js

@@ -113,7 +113,7 @@ function endsWithTemplateCurly(node) {
         return startsWithTemplateCurly(node.right);
     }
     if (node.type === "TemplateLiteral") {
-        return node.expressions.length && node.quasis.length && node.quasis[node.quasis.length - 1].range[0] === node.quasis[node.quasis.length - 1].range[1];
+        return node.expressions.length && node.quasis.length && node.quasis.at(-1).range[0] === node.quasis.at(-1).range[1];
     }
     return node.type !== "Literal" || typeof node.value !== "string";
 }

package/lib/rules/radix.js

@@ -133,8 +133,8 @@ module.exports = {
                                     messageId: "addRadixParameter10",
                                     fix(fixer) {
                                         const tokens = sourceCode.getTokens(node);
-                                        const lastToken = tokens[tokens.length - 1]; // Parenthesis.
-                                        const secondToLastToken = tokens[tokens.length - 2]; // May or may not be a comma.
+                                        const lastToken = tokens.at(-1); // Parenthesis.
+                                        const secondToLastToken = tokens.at(-2); // May or may not be a comma.
                                         const hasTrailingComma = secondToLastToken.type === "Punctuator" && secondToLastToken.value === ",";
 
                                         return fixer.insertTextBefore(lastToken, hasTrailingComma ? " 10," : ", 10");

package/lib/rules/semi-style.js

@@ -65,7 +65,7 @@ function isLastChild(node) {
     }
     const nodeList = getChildren(node.parent);
 
-    return nodeList !== null && nodeList[nodeList.length - 1] === node; // before `}` or etc.
+    return nodeList !== null && nodeList.at(-1) === node; // before `}` or etc.
 }
 
 /** @type {import('../shared/types').Rule} */

package/lib/rules/sort-imports.js

@@ -208,7 +208,7 @@ module.exports = {
                                 }
 
                                 return fixer.replaceTextRange(
-                                    [importSpecifiers[0].range[0], importSpecifiers[importSpecifiers.length - 1].range[1]],
+                                    [importSpecifiers[0].range[0], importSpecifiers.at(-1).range[1]],
                                     importSpecifiers
 
                                         // Clone the importSpecifiers array to avoid mutating it

package/lib/rules/sort-keys.js

@@ -185,7 +185,7 @@ module.exports = {
                     });
 
                     // check blank line between the current node and the last token
-                    if (!isBlankLineBetweenNodes && (node.loc.start.line - tokens[tokens.length - 1].loc.end.line > 1)) {
+                    if (!isBlankLineBetweenNodes && (node.loc.start.line - tokens.at(-1).loc.end.line > 1)) {
                         isBlankLineBetweenNodes = true;
                     }
 

package/lib/rules/sort-vars.js

@@ -66,7 +66,7 @@ module.exports = {
                                     return null;
                                 }
                                 return fixer.replaceTextRange(
-                                    [idDeclarations[0].range[0], idDeclarations[idDeclarations.length - 1].range[1]],
+                                    [idDeclarations[0].range[0], idDeclarations.at(-1).range[1]],
                                     idDeclarations
 
                                         // Clone the idDeclarations array to avoid mutating it

package/lib/rules/space-unary-ops.js

@@ -87,7 +87,7 @@ module.exports = {
          * @returns {boolean} Whether or not an override has been provided for the operator
          */
         function overrideExistsForOperator(operator) {
-            return options.overrides && Object.prototype.hasOwnProperty.call(options.overrides, operator);
+            return options.overrides && Object.hasOwn(options.overrides, operator);
         }
 
         /**

package/lib/rules/strict.js

@@ -173,7 +173,7 @@ module.exports = {
         function enterFunctionInFunctionMode(node, useStrictDirectives) {
             const isInClass = classScopes.length > 0,
                 isParentGlobal = scopes.length === 0 && classScopes.length === 0,
-                isParentStrict = scopes.length > 0 && scopes[scopes.length - 1],
+                isParentStrict = scopes.length > 0 && scopes.at(-1),
                 isStrict = useStrictDirectives.length > 0;
 
             if (isStrict) {

package/lib/rules/utils/ast-utils.js

@@ -969,7 +969,7 @@ function isConstant(scope, node, inBooleanPosition) {
             return false;
 
         case "SequenceExpression":
-            return isConstant(scope, node.expressions[node.expressions.length - 1], inBooleanPosition);
+            return isConstant(scope, node.expressions.at(-1), inBooleanPosition);
         case "SpreadElement":
             return isConstant(scope, node.argument, inBooleanPosition);
         case "CallExpression":
@@ -1231,7 +1231,7 @@ module.exports = {
      * @private
      */
     isSurroundedBy(val, character) {
-        return val[0] === character && val[val.length - 1] === character;
+        return val[0] === character && val.at(-1) === character;
     },
 
     /**
@@ -1909,8 +1909,8 @@ module.exports = {
      */
     getFunctionHeadLoc(node, sourceCode) {
         const parent = node.parent;
-        let start = null;
-        let end = null;
+        let start;
+        let end;
 
         if (parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") {
             start = parent.loc.start;
@@ -2055,7 +2055,7 @@ module.exports = {
             case "SequenceExpression": {
                 const exprs = node.expressions;
 
-                return exprs.length !== 0 && module.exports.couldBeError(exprs[exprs.length - 1]);
+                return exprs.length !== 0 && module.exports.couldBeError(exprs.at(-1));
             }
 
             case "LogicalExpression":
@@ -2119,9 +2119,9 @@ module.exports = {
 
             const comments = tokens.comments;
 
-            leftToken = tokens[tokens.length - 1];
+            leftToken = tokens.at(-1);
             if (comments.length) {
-                const lastComment = comments[comments.length - 1];
+                const lastComment = comments.at(-1);
 
                 if (!leftToken || lastComment.range[0] > leftToken.range[0]) {
                     leftToken = lastComment;

package/lib/rules/yield-star-spacing.js

@@ -79,7 +79,7 @@ module.exports = {
                 const after = leftToken.value === "*";
                 const spaceRequired = mode[side];
                 const node = after ? leftToken : rightToken;
-                let messageId = "";
+                let messageId;
 
                 if (spaceRequired) {
                     messageId = side === "before" ? "missingBefore" : "missingAfter";

package/lib/shared/serialization.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Serialization utils.
+ * @author Bryan Mishkin
+ */
+
+"use strict";
+
+/**
+ * Check if a value is a primitive or plain object created by the Object constructor.
+ * @param {any} val the value to check
+ * @returns {boolean} true if so
+ * @private
+ */
+function isSerializablePrimitiveOrPlainObject(val) {
+    return (
+        val === null ||
+        typeof val === "string" ||
+         typeof val === "boolean" ||
+         typeof val === "number" ||
+         (typeof val === "object" && val.constructor === Object) ||
+         Array.isArray(val)
+    );
+}
+
+/**
+ * Check if a value is serializable.
+ * Functions or objects like RegExp cannot be serialized by JSON.stringify().
+ * Inspired by: https://stackoverflow.com/questions/30579940/reliable-way-to-check-if-objects-is-serializable-in-javascript
+ * @param {any} val the value
+ * @returns {boolean} true if the value is serializable
+ */
+function isSerializable(val) {
+    if (!isSerializablePrimitiveOrPlainObject(val)) {
+        return false;
+    }
+    if (typeof val === "object") {
+        for (const property in val) {
+            if (Object.hasOwn(val, property)) {
+                if (!isSerializablePrimitiveOrPlainObject(val[property])) {
+                    return false;
+                }
+                if (typeof val[property] === "object") {
+                    if (!isSerializable(val[property])) {
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+    return true;
+}
+
+module.exports = {
+    isSerializable
+};

package/lib/source-code/source-code.js

@@ -415,10 +415,10 @@ class SourceCode extends TokenStore {
          * and uses match.index to get the correct line start indices.
          */
         while ((match = lineEndingPattern.exec(this.text))) {
-            this.lines.push(this.text.slice(this.lineStartIndices[this.lineStartIndices.length - 1], match.index));
+            this.lines.push(this.text.slice(this.lineStartIndices.at(-1), match.index));
             this.lineStartIndices.push(match.index + match[0].length);
         }
-        this.lines.push(this.text.slice(this.lineStartIndices[this.lineStartIndices.length - 1]));
+        this.lines.push(this.text.slice(this.lineStartIndices.at(-1)));
 
         // don't allow further modification of this object
         Object.freeze(this);
@@ -623,14 +623,14 @@ class SourceCode extends TokenStore {
          * See getIndexFromLoc for the motivation for this special case.
          */
         if (index === this.text.length) {
-            return { line: this.lines.length, column: this.lines[this.lines.length - 1].length };
+            return { line: this.lines.length, column: this.lines.at(-1).length };
         }
 
         /*
          * To figure out which line index is on, determine the last place at which index could
          * be inserted into lineStartIndices to keep the list sorted.
          */
-        const lineNumber = index >= this.lineStartIndices[this.lineStartIndices.length - 1]
+        const lineNumber = index >= this.lineStartIndices.at(-1)
             ? this.lineStartIndices.length
             : this.lineStartIndices.findIndex(el => index < el);
 

package/lib/source-code/token-store/index.js

@@ -37,8 +37,8 @@ function createIndexMap(tokens, comments) {
     const map = Object.create(null);
     let tokenIndex = 0;
     let commentIndex = 0;
-    let nextStart = 0;
-    let range = null;
+    let nextStart;
+    let range;
 
     while (tokenIndex < tokens.length || commentIndex < comments.length) {
         nextStart = (commentIndex < comments.length) ? comments[commentIndex].range[0] : Number.MAX_SAFE_INTEGER;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.0.0-alpha.0",
+  "version": "9.0.0-alpha.2",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -66,8 +66,8 @@
     "@eslint-community/eslint-utils": "^4.2.0",
     "@eslint-community/regexpp": "^4.6.1",
     "@eslint/eslintrc": "^3.0.0",
-    "@eslint/js": "9.0.0-alpha.0",
-    "@humanwhocodes/config-array": "^0.11.13",
+    "@eslint/js": "9.0.0-alpha.2",
+    "@humanwhocodes/config-array": "^0.11.14",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@nodelib/fs.walk": "^1.2.8",
     "ajv": "^6.12.4",
@@ -75,9 +75,9 @@
     "cross-spawn": "^7.0.2",
     "debug": "^4.3.2",
     "escape-string-regexp": "^4.0.0",
-    "eslint-scope": "^7.2.2",
+    "eslint-scope": "^8.0.0",
     "eslint-visitor-keys": "^3.4.3",
-    "espree": "^9.6.1",
+    "espree": "^10.0.0",
     "esquery": "^1.4.2",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",
@@ -127,7 +127,7 @@
     "esprima": "^4.0.1",
     "fast-glob": "^3.2.11",
     "fs-teardown": "^0.1.3",
-    "glob": "^7.1.6",
+    "glob": "^10.0.0",
     "got": "^11.8.3",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
@@ -135,7 +135,7 @@
     "load-perf": "^0.2.0",
     "markdown-it": "^12.2.0",
     "markdown-it-container": "^3.0.0",
-    "markdownlint": "^0.32.0",
+    "markdownlint": "^0.33.0",
     "markdownlint-cli": "^0.38.0",
     "marked": "^4.0.8",
     "memfs": "^3.0.1",

package/conf/config-schema.js

@@ -1,93 +0,0 @@
-/*
- * STOP!!! DO NOT MODIFY.
- *
- * This file is part of the ongoing work to move the eslintrc-style config
- * system into the @eslint/eslintrc package. This file needs to remain
- * unchanged in order for this work to proceed.
- *
- * If you think you need to change this file, please contact @nzakas first.
- *
- * Thanks in advance for your cooperation.
- */
-
-/**
- * @fileoverview Defines a schema for configs.
- * @author Sylvan Mably
- */
-
-"use strict";
-
-const baseConfigProperties = {
-    $schema: { type: "string" },
-    env: { type: "object" },
-    extends: { $ref: "#/definitions/stringOrStrings" },
-    globals: { type: "object" },
-    overrides: {
-        type: "array",
-        items: { $ref: "#/definitions/overrideConfig" },
-        additionalItems: false
-    },
-    parser: { type: ["string", "null"] },
-    parserOptions: { type: "object" },
-    plugins: { type: "array" },
-    processor: { type: "string" },
-    rules: { type: "object" },
-    settings: { type: "object" },
-    noInlineConfig: { type: "boolean" },
-    reportUnusedDisableDirectives: { type: "boolean" },
-
-    ecmaFeatures: { type: "object" } // deprecated; logs a warning when used
-};
-
-const configSchema = {
-    definitions: {
-        stringOrStrings: {
-            oneOf: [
-                { type: "string" },
-                {
-                    type: "array",
-                    items: { type: "string" },
-                    additionalItems: false
-                }
-            ]
-        },
-        stringOrStringsRequired: {
-            oneOf: [
-                { type: "string" },
-                {
-                    type: "array",
-                    items: { type: "string" },
-                    additionalItems: false,
-                    minItems: 1
-                }
-            ]
-        },
-
-        // Config at top-level.
-        objectConfig: {
-            type: "object",
-            properties: {
-                root: { type: "boolean" },
-                ignorePatterns: { $ref: "#/definitions/stringOrStrings" },
-                ...baseConfigProperties
-            },
-            additionalProperties: false
-        },
-
-        // Config in `overrides`.
-        overrideConfig: {
-            type: "object",
-            properties: {
-                excludedFiles: { $ref: "#/definitions/stringOrStrings" },
-                files: { $ref: "#/definitions/stringOrStringsRequired" },
-                ...baseConfigProperties
-            },
-            required: ["files"],
-            additionalProperties: false
-        }
-    },
-
-    $ref: "#/definitions/objectConfig"
-};
-
-module.exports = configSchema;