xo 0.53.1 → 0.54.0

package/config/plugins.cjs

@@ -222,9 +222,20 @@ module.exports = {
 			},
 		],
 		'import/no-useless-path-segments': 'error',
-		'import/newline-after-import': 'error',
+		'import/newline-after-import': [
+			'error',
+			{
+				// TODO: Buggy.
+				// considerComments: true,
+			},
+		],
 		'import/no-amd': 'error',
-		'import/no-duplicates': 'error',
+		'import/no-duplicates': [
+			'error',
+			{
+				'prefer-inline': true,
+			},
+		],
 
 		// We use `unicorn/prefer-module` instead.
 		// 'import/no-commonjs': 'error',
@@ -232,7 +243,13 @@ module.exports = {
 		// Looks useful, but too unstable at the moment
 		// 'import/no-deprecated': 'error',
 
-		'import/no-extraneous-dependencies': 'error',
+		'import/no-empty-named-blocks': 'error',
+		'import/no-extraneous-dependencies': [
+			'error',
+			{
+				includeTypes: true,
+			},
+		],
 		'import/no-mutable-exports': 'error',
 		'import/no-named-as-default-member': 'error',
 		'import/no-named-as-default': 'error',
@@ -245,7 +262,13 @@ module.exports = {
 		// 	}
 		// ],
 
-		'import/order': 'error',
+		'import/order': [
+			'error',
+			{
+				'newlines-between': 'never',
+				warnOnUnassignedImports: true,
+			},
+		],
 		'import/no-unassigned-import': [
 			'error',
 			{

package/lib/options-manager.js

@@ -2,7 +2,6 @@ import {existsSync, promises as fs} from 'node:fs';
 import process from 'node:process';
 import os from 'node:os';
 import path from 'node:path';
-import {createRequire} from 'node:module';
 import arrify from 'arrify';
 import {mergeWith, flow, pick} from 'lodash-es';
 import {findUpSync} from 'find-up';
@@ -11,12 +10,12 @@ import prettier from 'prettier';
 import semver from 'semver';
 import {cosmiconfig, defaultLoaders} from 'cosmiconfig';
 import micromatch from 'micromatch';
-import JSON5 from 'json5';
 import stringify from 'json-stable-stringify-without-jsonify';
 import {Legacy} from '@eslint/eslintrc';
 import createEsmUtils from 'esm-utils';
 import MurmurHash3 from 'imurmurhash';
 import slash from 'slash';
+import {getTsconfig} from 'get-tsconfig';
 import {
 	DEFAULT_IGNORES,
 	DEFAULT_EXTENSION,
@@ -159,26 +158,20 @@ const handleTSConfig = async options => {
 	options.tsConfig = {};
 	options.tsConfigPath = '';
 
-	const {project: tsConfigProjectPath, tsconfigRootDir} = options.parserOptions || {};
+	const {project: tsConfigProjectPath} = options.parserOptions || {};
 
 	if (tsConfigProjectPath) {
 		options.tsConfigPath = path.resolve(options.cwd, tsConfigProjectPath);
-		options.tsConfig = JSON5.parse(await fs.readFile(options.tsConfigPath));
+		options.tsConfig = tsConfigResolvePaths(getTsconfig(options.tsConfigPath).config, options.tsConfigPath);
 	} else {
-		const tsConfigExplorer = cosmiconfig([], {
-			searchPlaces: ['tsconfig.json'],
-			loaders: {'.json': (_, content) => JSON5.parse(content)},
-			stopDir: tsconfigRootDir,
-		});
-		const searchResults = (await tsConfigExplorer.search(options.filePath)) || {};
-		options.tsConfigPath = searchResults.filepath;
-		options.tsConfig = searchResults.config;
-	}
-
-	if (options.tsConfig) {
-		// If the tsconfig extends from another file, we need to ensure that the file is covered by the tsconfig
-		// or not. The basefile could have includes/excludes/files properties that should be applied to the final tsconfig representation.
-		options.tsConfig = await recursiveBuildTsConfig(options.tsConfig, options.tsConfigPath);
+		const {config: tsConfig, path: filepath} = getTsconfig(options.filePath) || {};
+		options.tsConfigPath = filepath;
+		options.tsConfig = tsConfig;
+		if (options.tsConfigPath) {
+			options.tsConfig = tsConfigResolvePaths(tsConfig, options.tsConfigPath);
+		} else {
+			delete options.tsConfig;
+		}
 	}
 
 	let hasMatch;
@@ -637,46 +630,6 @@ const getOptionGroups = async (files, options) => {
 	return optionGroups;
 };
 
-async function recursiveBuildTsConfig(tsConfig, tsConfigPath) {
-	tsConfig = tsConfigResolvePaths(tsConfig, tsConfigPath);
-
-	if (!tsConfig.extends || (typeof tsConfig.extends === 'string' && tsConfig.extends.includes('node_modules'))) {
-		return tsConfig;
-	}
-
-	// If any of the following are missing, then we need to look up the base config as it could apply
-	const require = createRequire(tsConfigPath);
-
-	let basePath;
-	try {
-		basePath = require.resolve(tsConfig.extends);
-	} catch (error) {
-		// Tsconfig resolution is odd, It allows behavior that is not exactly like node resolution
-		// therefore we attempt to smooth this out here with this hack
-		try {
-			basePath = require.resolve(path.join(tsConfig.extends, 'tsconfig.json'));
-		} catch {
-			// Throw the orginal resolution error to let the user know their extends block is invalid
-			throw error;
-		}
-	}
-
-	const baseTsConfig = JSON5.parse(await fs.readFile(basePath));
-
-	delete tsConfig.extends;
-
-	tsConfig = {
-		compilerOptions: {
-			...baseTsConfig.compilerOptions,
-			...tsConfig.compilerOptions,
-		},
-		...baseTsConfig,
-		...tsConfig,
-	};
-
-	return recursiveBuildTsConfig(tsConfig, basePath);
-}
-
 // Convert all include, files, and exclude to absolute paths
 // and or globs. This works because ts only allows simple glob subset
 const tsConfigResolvePaths = (tsConfig, tsConfigPath) => {

package/node_modules/@eslint-community/eslint-utils/README.md

@@ -0,0 +1,37 @@
+# @eslint-community/eslint-utils
+
+[![npm version](https://img.shields.io/npm/v/@eslint-community/eslint-utils.svg)](https://www.npmjs.com/package/@eslint-community/eslint-utils)
+[![Downloads/month](https://img.shields.io/npm/dm/@eslint-community/eslint-utils.svg)](http://www.npmtrends.com/@eslint-community/eslint-utils)
+[![Build Status](https://github.com/eslint-community/eslint-utils/workflows/CI/badge.svg)](https://github.com/eslint-community/eslint-utils/actions)
+[![Coverage Status](https://codecov.io/gh/eslint-community/eslint-utils/branch/main/graph/badge.svg)](https://codecov.io/gh/eslint-community/eslint-utils)
+
+## 🏁 Goal
+
+This package provides utility functions and classes for make ESLint custom rules.
+
+For examples:
+
+-   [`getStaticValue`](https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstaticvalue) evaluates static value on AST.
+-   [`ReferenceTracker`](https://eslint-community.github.io/eslint-utils/api/scope-utils.html#referencetracker-class) checks the members of modules/globals as handling assignments and destructuring.
+
+## 📖 Usage
+
+See [documentation](https://eslint-community.github.io/eslint-utils).
+
+## 📰 Changelog
+
+See [releases](https://github.com/eslint-community/eslint-utils/releases).
+
+## ❤️ Contributing
+
+Welcome contributing!
+
+Please use GitHub's Issues/PRs.
+
+### Development Tools
+
+-   `npm test` runs tests and measures coverage.
+-   `npm run clean` removes the coverage result of `npm test` command.
+-   `npm run coverage` shows the coverage result of the last `npm test` command.
+-   `npm run lint` runs ESLint.
+-   `npm run watch` runs tests on each file change.

package/node_modules/{eslint-utils → @eslint-community/eslint-utils}/index.js

@@ -1,11 +1,8 @@
-/*! @author Toru Nagashima <https://github.com/mysticatea> */
 'use strict';
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var evk = _interopDefault(require('eslint-visitor-keys'));
+var eslintVisitorKeys = require('eslint-visitor-keys');
 
 /**
  * Get the innermost scope which contains a given location.
@@ -313,6 +310,24 @@ const builtinNames = Object.freeze(
 const callAllowed = new Set(
     [
         Array.isArray,
+        Array.of,
+        Array.prototype.at,
+        Array.prototype.concat,
+        Array.prototype.entries,
+        Array.prototype.every,
+        Array.prototype.filter,
+        Array.prototype.find,
+        Array.prototype.findIndex,
+        Array.prototype.flat,
+        Array.prototype.includes,
+        Array.prototype.indexOf,
+        Array.prototype.join,
+        Array.prototype.keys,
+        Array.prototype.lastIndexOf,
+        Array.prototype.slice,
+        Array.prototype.some,
+        Array.prototype.toString,
+        Array.prototype.values,
         typeof BigInt === "function" ? BigInt : undefined,
         Boolean,
         Date,
@@ -325,7 +340,14 @@ const callAllowed = new Set(
         isFinite,
         isNaN,
         isPrototypeOf,
+        Map,
+        Map.prototype.entries,
+        Map.prototype.get,
+        Map.prototype.has,
+        Map.prototype.keys,
+        Map.prototype.values,
         ...Object.getOwnPropertyNames(Math)
+            .filter((k) => k !== "random")
             .map((k) => Math[k])
             .filter((f) => typeof f === "function"),
         Number,
@@ -333,6 +355,10 @@ const callAllowed = new Set(
         Number.isNaN,
         Number.parseFloat,
         Number.parseInt,
+        Number.prototype.toExponential,
+        Number.prototype.toFixed,
+        Number.prototype.toPrecision,
+        Number.prototype.toString,
         Object,
         Object.entries,
         Object.is,
@@ -344,10 +370,39 @@ const callAllowed = new Set(
         parseFloat,
         parseInt,
         RegExp,
+        Set,
+        Set.prototype.entries,
+        Set.prototype.has,
+        Set.prototype.keys,
+        Set.prototype.values,
         String,
         String.fromCharCode,
         String.fromCodePoint,
         String.raw,
+        String.prototype.at,
+        String.prototype.charAt,
+        String.prototype.charCodeAt,
+        String.prototype.codePointAt,
+        String.prototype.concat,
+        String.prototype.endsWith,
+        String.prototype.includes,
+        String.prototype.indexOf,
+        String.prototype.lastIndexOf,
+        String.prototype.normalize,
+        String.prototype.padEnd,
+        String.prototype.padStart,
+        String.prototype.slice,
+        String.prototype.startsWith,
+        String.prototype.substr,
+        String.prototype.substring,
+        String.prototype.toLowerCase,
+        String.prototype.toString,
+        String.prototype.toUpperCase,
+        String.prototype.trim,
+        String.prototype.trimEnd,
+        String.prototype.trimLeft,
+        String.prototype.trimRight,
+        String.prototype.trimStart,
         Symbol.for,
         Symbol.keyFor,
         unescape,
@@ -359,6 +414,26 @@ const callPassThrough = new Set([
     Object.seal,
 ]);
 
+/** @type {ReadonlyArray<readonly [Function, ReadonlySet<string>]>} */
+const getterAllowed = [
+    [Map, new Set(["size"])],
+    [
+        RegExp,
+        new Set([
+            "dotAll",
+            "flags",
+            "global",
+            "hasIndices",
+            "ignoreCase",
+            "multiline",
+            "source",
+            "sticky",
+            "unicode",
+        ]),
+    ],
+    [Set, new Set(["size"])],
+];
+
 /**
  * Get the property descriptor.
  * @param {object} object The object to get.
@@ -418,6 +493,23 @@ function getElementValues(nodeList, initialScope) {
     return valueList
 }
 
+/**
+ * Returns whether the given variable is never written to after initialization.
+ * @param {import("eslint").Scope.Variable} variable
+ * @returns {boolean}
+ */
+function isEffectivelyConst(variable) {
+    const refs = variable.references;
+
+    const inits = refs.filter((r) => r.init).length;
+    const reads = refs.filter((r) => r.isReadOnly()).length;
+    if (inits === 1 && reads + inits === refs.length) {
+        // there is only one init and all other references only read
+        return true
+    }
+    return false
+}
+
 const operations = Object.freeze({
     ArrayExpression(node, initialScope) {
         const elements = getElementValues(node.elements, initialScope);
@@ -475,7 +567,7 @@ const operations = Object.freeze({
                 case "%":
                     return { value: left.value % right.value }
                 case "**":
-                    return { value: Math.pow(left.value, right.value) }
+                    return { value: left.value ** right.value }
                 case "|":
                     return { value: left.value | right.value }
                 case "^":
@@ -576,7 +668,9 @@ const operations = Object.freeze({
                 const def = variable.defs[0];
                 if (
                     def.parent &&
-                    def.parent.kind === "const" &&
+                    def.type === "Variable" &&
+                    (def.parent.kind === "const" ||
+                        isEffectivelyConst(variable)) &&
                     // TODO(mysticatea): don't support destructuring here.
                     def.node.id.type === "Identifier"
                 ) {
@@ -627,8 +721,19 @@ const operations = Object.freeze({
             }
             const property = getStaticPropertyNameValue(node, initialScope);
 
-            if (property != null && !isGetter(object.value, property.value)) {
-                return { value: object.value[property.value] }
+            if (property != null) {
+                if (!isGetter(object.value, property.value)) {
+                    return { value: object.value[property.value] }
+                }
+
+                for (const [classFn, allowed] of getterAllowed) {
+                    if (
+                        object.value instanceof classFn &&
+                        allowed.has(property.value)
+                    ) {
+                        return { value: object.value[property.value] }
+                    }
+                }
             }
         }
         return null
@@ -957,6 +1062,11 @@ function getFunctionNameWithKind(node, sourceCode) {
         parent.left.type === "Identifier"
     ) {
         tokens.push(`'${parent.left.name}'`);
+    } else if (
+        parent.type === "ExportDefaultDeclaration" &&
+        parent.declaration === node
+    ) {
+        tokens.push("'default'");
     }
 
     return tokens.join(" ")
@@ -1010,7 +1120,7 @@ const visitor = Object.freeze(
         $visitChildren(node, options, visitorKeys) {
             const { type } = node;
 
-            for (const key of visitorKeys[type] || evk.getKeys(node)) {
+            for (const key of visitorKeys[type] || eslintVisitorKeys.getKeys(node)) {
                 const value = node[key];
 
                 if (Array.isArray(value)) {
@@ -1136,7 +1246,7 @@ const visitor = Object.freeze(
  * @param {object} [options] The option object.
  * @param {boolean} [options.considerGetters=false] If `true` then it considers member accesses as the node which has side effects.
  * @param {boolean} [options.considerImplicitTypeConversion=false] If `true` then it considers implicit type conversion as the node which has side effects.
- * @param {object} [options.visitorKeys=evk.KEYS] The keys to traverse nodes. Use `context.getSourceCode().visitorKeys`.
+ * @param {object} [options.visitorKeys=KEYS] The keys to traverse nodes. Use `context.getSourceCode().visitorKeys`.
  * @returns {boolean} `true` if the node has a certain side effect.
  */
 function hasSideEffect(
@@ -1147,7 +1257,7 @@ function hasSideEffect(
     return visitor.$visit(
         node,
         { considerGetters, considerImplicitTypeConversion },
-        sourceCode.visitorKeys || evk.KEYS,
+        sourceCode.visitorKeys || eslintVisitorKeys.KEYS,
     )
 }
 
@@ -1245,6 +1355,8 @@ function isParenthesized(
 
     if (
         node == null ||
+        // `Program` can't be parenthesized
+        node.parent == null ||
         // `CatchClause.param` can't be parenthesized, example `try {} catch (error) {}`
         (node.parent.type === "CatchClause" && node.parent.param === node)
     ) {
@@ -1921,7 +2033,7 @@ exports.ESM = ESM;
 exports.PatternMatcher = PatternMatcher;
 exports.READ = READ;
 exports.ReferenceTracker = ReferenceTracker;
-exports.default = index;
+exports["default"] = index;
 exports.findVariable = findVariable;
 exports.getFunctionHeadLocation = getFunctionHeadLocation;
 exports.getFunctionNameWithKind = getFunctionNameWithKind;