xo 0.53.1 → 0.54.1

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-mixed-enums.md

@@ -0,0 +1,88 @@
+---
+description: 'Disallow enums from having both number and string members.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/no-mixed-enums** for documentation.
+
+TypeScript enums are allowed to assign numeric or string values to their members.
+Most enums contain either all numbers or all strings, but in theory you can mix-and-match within the same enum.
+Mixing enum member types is generally considered confusing and a bad practice.
+
+## Examples
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+enum Status {
+  Unknown,
+  Closed = 1,
+  Open = 'open',
+}
+```
+
+### ✅ Correct (Explicit Numbers)
+
+```ts
+enum Status {
+  Unknown = 0,
+  Closed = 1,
+  Open = 2,
+}
+```
+
+### ✅ Correct (Implicit Numbers)
+
+```ts
+enum Status {
+  Unknown,
+  Closed,
+  Open,
+}
+```
+
+### ✅ Correct (Strings)
+
+```ts
+enum Status {
+  Unknown = 'unknown',
+  Closed = 'closed',
+  Open = 'open',
+}
+```
+
+## Iteration Pitfalls of Mixed Enum Member Values
+
+Enum values may be iterated over using `Object.entries`/`Object.keys`/`Object.values`.
+
+If all enum members are strings, the number of items will match the number of enum members:
+
+```ts
+enum Status {
+  Closed = 'closed',
+  Open = 'open',
+}
+
+// ['closed', 'open']
+Object.values(Status);
+```
+
+But if the enum contains members that are initialized with numbers -including implicitly initialized numbers— then iteration over that enum will include those numbers as well:
+
+```ts
+enum Status {
+  Unknown,
+  Closed = 1,
+  Open = 'open',
+}
+
+// ["Unknown", "Closed", 0, 1, "open"]
+Object.values(Status);
+```
+
+## When Not To Use It
+
+If you don't mind the confusion of mixed enum member values and don't iterate over enums, you can safely disable this rule.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-non-null-assertion.md

@@ -22,7 +22,7 @@ interface Example {
 }
 
 declare const example: Example;
-const includesBaz = foo.property!.includes('baz');
+const includesBaz = example.property!.includes('baz');
 ```
 
 ### ✅ Correct
@@ -33,7 +33,7 @@ interface Example {
 }
 
 declare const example: Example;
-const includesBaz = foo.property?.includes('baz') ?? false;
+const includesBaz = example.property?.includes('baz') ?? false;
 ```
 
 ## When Not To Use It

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-shadow.md

@@ -78,3 +78,24 @@ Examples of **correct** code with `{ ignoreFunctionTypeParameterNameValueShadow:
 const test = 1;
 type Func = (test: string) => typeof test;
 ```
+
+## FAQ
+
+### Why does the rule report on enum members that share the same name as a variable in a parent scope?
+
+Reporting on this case isn't a bug - it is completely intentional and correct reporting! The rule reports due to a relatively unknown feature of enums - enum members create a variable within the enum scope so that they can be referenced within the enum without a qualifier.
+
+To illustrate this with an example:
+
+```ts
+const A = 2;
+enum Test {
+  A = 1,
+  B = A,
+}
+
+console.log(Test.B);
+// what should be logged?
+```
+
+Naively looking at the above code, it might look like the log should output `2`, because the outer variable `A`'s value is `2` - however, the code instead outputs `1`, which is the value of `Test.A`. This is because the unqualified code `B = A` is equivalent to the fully-qualified code `B = Test.A`. Due to this behavior, the enum member has **shadowed** the outer variable declaration.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-unsafe-enum-comparison.md

@@ -0,0 +1,75 @@
+---
+description: 'Disallow comparing an enum value with a non-enum value.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/no-unsafe-enum-comparison** for documentation.
+
+The TypeScript compiler can be surprisingly lenient when working with enums.
+For example, it will allow you to compare enum values against numbers even though they might not have any type overlap:
+
+```ts
+enum Fruit {
+  Apple,
+  Banana,
+}
+
+declare let fruit: Fruit;
+
+fruit === 999; // No error
+```
+
+This rule flags when an enum typed value is compared to a non-enum `number`.
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+enum Fruit {
+  Apple,
+}
+
+declare let fruit: Fruit;
+
+fruit === 999;
+```
+
+```ts
+enum Vegetable {
+  Asparagus = 'asparagus',
+}
+
+declare let vegetable: Vegetable;
+
+vegetable === 'asparagus';
+```
+
+### ✅ Correct
+
+```ts
+enum Fruit {
+  Apple,
+}
+
+declare let fruit: Fruit;
+
+fruit === Fruit.Banana;
+```
+
+```ts
+enum Vegetable {
+  Asparagus = 'asparagus',
+}
+
+declare let vegetable: Vegetable;
+
+vegetable === Vegetable.Asparagus;
+```
+
+<!--/tabs-->
+
+## When Not to Use It
+
+If you don't mind number and/or literal string constants being compared against enums, you likely don't need this rule.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-function-type.md

@@ -85,3 +85,8 @@ type Intersection = ((data: string) => number) & ((id: number) => string);
 ## When Not To Use It
 
 If you specifically want to use an interface or type literal with a single call signature for stylistic reasons, you can disable this rule.
+
+This rule has a known edge case of sometimes triggering on global augmentations such as `interface Function`.
+These edge cases are rare and often symptomatic of odd code.
+We recommend you use an [inline ESLint disable comment](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1).
+See [#454](https://github.com/typescript-eslint/typescript-eslint/issues/454) for details.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/promise-function-async.md

@@ -11,10 +11,12 @@ Ensures that each function is only capable of:
 - returning a rejected promise, or
 - throwing an Error object.
 
-In contrast, non-`async` `Promise` - returning functions are technically capable of either.
+In contrast, non-`async`, `Promise`-returning functions are technically capable of either.
 Code that handles the results of those functions will often need to handle both cases, which can get complex.
 This rule's practice removes a requirement for creating code to handle both cases.
 
+> When functions return unions of `Promise` and non-`Promise` types implicitly, it is usually a mistake—this rule flags those cases. If it is intentional, make the return type explicitly to allow the rule to pass.
+
 ## Examples
 
 Examples of code for this rule
@@ -29,6 +31,10 @@ const arrowFunctionReturnsPromise = () => Promise.resolve('value');
 function functionReturnsPromise() {
   return Promise.resolve('value');
 }
+
+function functionReturnsUnionWithPromiseImplicitly(p: boolean) {
+  return p ? 'value' : Promise.resolve('value');
+}
 ```
 
 ### ✅ Correct
@@ -39,4 +45,15 @@ const arrowFunctionReturnsPromise = async () => Promise.resolve('value');
 async function functionReturnsPromise() {
   return Promise.resolve('value');
 }
+
+// An explicit return type that is not Promise means this function cannot be made async, so it is ignored by the rule
+function functionReturnsUnionWithPromiseExplicitly(
+  p: boolean,
+): string | Promise<string> {
+  return p ? 'value' : Promise.resolve('value');
+}
+
+async function functionReturnsUnionWithPromiseImplicitly(p: boolean) {
+  return p ? 'value' : Promise.resolve('value');
+}
 ```

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/restrict-template-expressions.md

@@ -90,6 +90,15 @@ const arg = /foo/;
 const msg1 = `arg = ${arg}`;
 ```
 
+### `allowNever`
+
+Examples of additional **correct** code for this rule with `{ allowNever: true }`:
+
+```ts
+const arg = 'something';
+const msg1 = typeof arg === 'string' ? arg : `arg = ${arg}`;
+```
+
 ## Related To
 
 - [`no-base-to-string`](./no-base-to-string.md)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/strict-boolean-expressions.md

@@ -124,6 +124,12 @@ Allows `number | null | undefined` in a boolean context.
 This is unsafe because nullable numbers can be either a falsy number or nullish.
 Set this to `true` if you don't mind implicitly treating zero or NaN the same as a nullish value.
 
+### `allowNullableEnum`
+
+Allows `enum | null | undefined` in a boolean context.
+This is unsafe because nullable enums can be either a falsy number or nullish.
+Set this to `true` if you don't mind implicitly treating an enum whose value is zero the same as a nullish value.
+
 ### `allowAny`
 
 Allows `any` in a boolean context.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/unified-signatures.md

@@ -38,6 +38,13 @@ function x(x: number | string): void;
 function y(...x: number[]): void;
 ```
 
+```ts
+// This rule won't check overload signatures with different rest parameter types.
+// See https://github.com/microsoft/TypeScript/issues/5077
+function f(...a: number[]): void;
+function f(...a: string[]): void;
+```
+
 ## Options
 
 ### `ignoreDifferentlyNamedParameters`
@@ -53,11 +60,6 @@ function f(a: number): void;
 function f(a: string): void;
 ```
 
-```ts
-function f(...a: number[]): void;
-function f(...b: string[]): void;
-```
-
 ### ✅ Correct
 
 ```ts
@@ -65,9 +67,4 @@ function f(a: number): void;
 function f(b: string): void;
 ```
 
-```ts
-function f(...a: number[]): void;
-function f(...a: string[]): void;
-```
-
 ## Options

package/node_modules/@typescript-eslint/eslint-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "5.43.0",
+  "version": "5.58.0",
   "description": "TypeScript plugin for ESLint",
   "keywords": [
     "eslint",
@@ -37,20 +37,21 @@
     "clean": "tsc -b tsconfig.build.json --clean",
     "postclean": "rimraf dist && rimraf coverage",
     "format": "prettier --write \"./**/*.{ts,mts,cts,tsx,js,mjs,cjs,jsx,json,md,css}\" --ignore-path ../../.prettierignore",
-    "generate:configs": "../../node_modules/.bin/ts-node --files --transpile-only tools/generate-configs.ts",
-    "generate:rules-lists": "../../node_modules/.bin/ts-node --files --transpile-only tools/generate-rules-lists.ts",
-    "lint": "eslint . --ignore-path ../../.eslintignore",
+    "generate:breaking-changes": "yarn tsx tools/generate-breaking-changes.ts",
+    "generate:configs": "yarn tsx tools/generate-configs.ts",
+    "lint": "nx lint",
     "test": "jest --coverage",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/scope-manager": "5.43.0",
-    "@typescript-eslint/type-utils": "5.43.0",
-    "@typescript-eslint/utils": "5.43.0",
+    "@eslint-community/regexpp": "^4.4.0",
+    "@typescript-eslint/scope-manager": "5.58.0",
+    "@typescript-eslint/type-utils": "5.58.0",
+    "@typescript-eslint/utils": "5.58.0",
     "debug": "^4.3.4",
+    "grapheme-splitter": "^1.0.4",
     "ignore": "^5.2.0",
     "natural-compare-lite": "^1.4.0",
-    "regexpp": "^3.2.0",
     "semver": "^7.3.7",
     "tsutils": "^3.21.0"
   },
@@ -61,7 +62,10 @@
     "@types/natural-compare-lite": "^1.4.0",
     "@types/prettier": "*",
     "chalk": "^5.0.1",
+    "cross-fetch": "^3.1.5",
+    "grapheme-splitter": "^1.0.4",
     "json-schema": "*",
+    "markdown-table": "^3.0.2",
     "marked": "^4.0.15",
     "prettier": "*",
     "title-case": "^3.0.3",
@@ -80,5 +84,5 @@
     "type": "opencollective",
     "url": "https://opencollective.com/typescript-eslint"
   },
-  "gitHead": "8af1b4d970438b27ea041717bddadc41af8fc72a"
+  "gitHead": "0c6b63658aa5b01188480150fd777a1fa9b277eb"
 }

package/node_modules/@typescript-eslint/parser/LICENSE

@@ -4,11 +4,11 @@ Copyright JS Foundation and other contributors, https://js.foundation
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 
-  * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-  * Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
+- Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE