eslint-plugin-etc-misc 1.1.6 → 1.1.8

package/docs/rules/consistent-enum-members.md

@@ -9,18 +9,18 @@ This rule analyzes TypeScript `TSEnumMember` nodes and validates naming for:
 - enum member identifiers (for example `ACTIVE_USER`), and
 - string literal member values when provided.
 
-It enforces SCREAMING\_SNAKE\_CASE in both places.
+It enforces SCREAMING_SNAKE_CASE in both places.
 
 ## What this rule reports
 
 This rule reports enum members when **neither** of these matches
-SCREAMING\_SNAKE\_CASE:
+SCREAMING_SNAKE_CASE:
 
 - the member identifier name, or
 - the string literal initializer value.
 
 In other words, the current implementation accepts a member if either side is
-already SCREAMING\_SNAKE\_CASE.
+already SCREAMING_SNAKE_CASE.
 
 ## Why this rule exists
 

package/docs/rules/consistent-filename.md

@@ -4,7 +4,7 @@ Enforce filename casing consistency.
 
 ## Targeted pattern scope
 
-This rule validates the current file’s stem (filename without extension) against
+This rule validates the current file's stem (filename without extension) against
 one configured casing format.
 
 ## What this rule reports

package/docs/rules/getting-started.md

@@ -16,9 +16,7 @@ Enable one preset in your Flat Config:
 ```ts
 import etcMisc from "eslint-plugin-etc-misc";
 
-export default [
-    etcMisc.configs.recommended,
-];
+export default [etcMisc.configs.recommended];
 ```
 
 Use `minimal` or `recommended` first, then move through stricter presets as
@@ -33,24 +31,24 @@ import tsParser from "@typescript-eslint/parser";
 import etcMisc from "eslint-plugin-etc-misc";
 
 export default [
-    {
-        files: ["**/*.{ts,tsx,mts,cts}"],
-        languageOptions: {
-            parser: tsParser,
-            parserOptions: {
-                ecmaVersion: "latest",
-                // Enable only when using a type-aware preset.
-                // projectService: true,
-                sourceType: "module",
-            },
-        },
-        plugins: {
-            "etc-misc": etcMisc,
-        },
-        rules: {
-            ...etcMisc.configs.recommended.rules,
-        },
-    },
+ {
+  files: ["**/*.{ts,tsx,mts,cts}"],
+  languageOptions: {
+   parser: tsParser,
+   parserOptions: {
+    ecmaVersion: "latest",
+    // Enable only when using a type-aware preset.
+    // projectService: true,
+    sourceType: "module",
+   },
+  },
+  plugins: {
+   "etc-misc": etcMisc,
+  },
+  rules: {
+   ...etcMisc.configs.recommended.rules,
+  },
+ },
 ];
 ```
 

package/docs/rules/no-assign-mutated-array.md

@@ -26,20 +26,12 @@ mutating shared state, which causes subtle bugs.
 ## ❌ Incorrect
 
 ```ts
-const names = [
- "c",
- "a",
- "b",
-];
+const names = ["c", "a", "b"];
 const sorted = names.sort();
 ```
 
 ```ts
-const names = [
- "c",
- "a",
- "b",
-];
+const names = ["c", "a", "b"];
 print(names.reverse());
 ```
 
@@ -51,29 +43,17 @@ return sorted;
 ## ✅ Correct
 
 ```ts
-const names = [
- "c",
- "a",
- "b",
-];
+const names = ["c", "a", "b"];
 names.sort();
 ```
 
 ```ts
-const names = [
- "c",
- "a",
- "b",
-];
+const names = ["c", "a", "b"];
 const sorted = names.slice().sort();
 ```
 
 ```ts
-const names = [
- "c",
- "a",
- "b",
-];
+const names = ["c", "a", "b"];
 const sorted = names.map((name) => name).reverse();
 ```
 

package/docs/rules/no-expression-empty-lines.md

@@ -4,7 +4,7 @@ Disallow blank lines inside expression statements.
 
 ## Targeted pattern scope
 
-This rule inspects `ExpressionStatement` nodes and checks the expression’s raw
+This rule inspects `ExpressionStatement` nodes and checks the expression's raw
 source text for blank lines.
 
 It only applies to expression statements and does not inspect declarations,
@@ -23,9 +23,7 @@ formatting noise.
 ## ❌ Incorrect
 
 ```ts
-someCall(
-
-    1);
+someCall(1);
 ```
 
 ## ✅ Correct

package/docs/rules/no-foreach.md

@@ -61,11 +61,7 @@ Use this option to control which type names are checked.
 ## Additional examples
 
 ```ts
-const set = new Set([
- 1,
- 2,
- 3,
-]);
+const set = new Set([1, 2, 3]);
 set.forEach((value) => console.log(value));
 // ❌ reported with default options
 

package/docs/rules/no-function-declare-after-return.md

@@ -2,30 +2,42 @@
 
 Disallow function declarations that appear after a `return` statement in the same block scope.
 
-## Why this rule is included here
+## Targeted pattern scope
 
-This rule was integrated into `eslint-plugin-etc-misc` to avoid requiring a separate single-rule plugin dependency.
+This rule reports `FunctionDeclaration` nodes that appear after a `ReturnStatement` in the same direct statement list (`BlockStatement` or `Program`).
 
-Original plugin source: [`eslint-plugin-no-function-declare-after-return`](https://github.com/bhumijgupta/eslint-plugin-no-function-declare-after-return).
+- `return` inside `switch` cases is out of scope for this rule.
+- Function declarations nested inside later `if`/`try`/`for` blocks are not directly targeted by this rule.
 
-## Rule details
+> **Note:** This rule targets only `FunctionDeclaration` nodes. Arrow functions,
+> function expressions, generator functions, and async function expressions
+> assigned to variables are **not** flagged — those are expression statements and
+> are genuinely unreachable. Use `no-unreachable` for those cases.
+
+## What this rule reports
 
 JavaScript hoists `function` declarations to the top of their enclosing scope,
 which means the following code is syntactically valid and runs without errors:
 
 ```ts
 function publicMethods(obj) {
-    if (obj instanceof CustomClass) {
-        return {
-            get: methodGetter(obj), // ← called before its declaration ❌
-        };
-    }
-    function methodGetter(obj) { // ← declared after the return
-        // …
-    }
+ if (obj instanceof CustomClass) {
+  return {
+   get: methodGetter(obj), // ← called before its declaration ❌
+  };
+ }
+ function methodGetter(obj) {
+  // ← declared after the return
+  // …
+ }
 }
 ```
 
+This rule reports function declarations that rely on that hoisting by appearing
+after an earlier `return` in the same block.
+
+## Why this rule exists
+
 Even though this works at runtime, it is a readability trap:
 
 - A reader scanning the function top-to-bottom will encounter the call to
@@ -39,39 +51,29 @@ This rule enforces that every `FunctionDeclaration` is placed **before** any
 `ReturnStatement` in the same block scope, making hoisting irrelevant from a
 readability perspective.
 
-### Scope boundaries
-
-This rule reports only when the function declaration is a **direct sibling** of
-the `return` statement in the same statement list (`BlockStatement` or
-`Program`).
-
-- `return` inside `switch` cases is out of scope for this rule.
-- Function declarations nested inside later `if`/`try`/`for` blocks are not directly targeted by this rule.
-
-> **Note:** This rule targets only `FunctionDeclaration` nodes. Arrow functions,
-> function expressions, generator functions, and async function expressions
-> assigned to variables are **not** flagged — those are expression statements and
-> are genuinely unreachable. Use `no-unreachable` for those cases.
-
 ## ❌ Incorrect
 
 ```ts
 function outer() {
-    return 42;
-    function helper() {} // ← 'helper' should be moved before the return
+ return 42;
+ function helper() {} // ← 'helper' should be moved before the return
 }
 ```
 
 ```ts
 function publicMethods(obj) {
-    if (obj) {
-        return {
-            set: methodSetter(obj),
-            get: methodGetter(obj),
-        };
-        function methodSetter(obj) { /* … */ } // ← should be before return
-        function methodGetter(obj) { /* … */ } // ← should be before return
-    }
+ if (obj) {
+  return {
+   set: methodSetter(obj),
+   get: methodGetter(obj),
+  };
+  function methodSetter(obj) {
+   /* … */
+  } // ← should be before return
+  function methodGetter(obj) {
+   /* … */
+  } // ← should be before return
+ }
 }
 ```
 
@@ -79,21 +81,25 @@ function publicMethods(obj) {
 
 ```ts
 function outer() {
-    function helper() {} // ← declared before the return
-    return helper();
+ function helper() {} // ← declared before the return
+ return helper();
 }
 ```
 
 ```ts
 function publicMethods(obj) {
-    function methodSetter(obj) { /* … */ } // ← before the return
-    function methodGetter(obj) { /* … */ } // ← before the return
-    if (obj) {
-        return {
-            set: methodSetter(obj),
-            get: methodGetter(obj),
-        };
-    }
+ function methodSetter(obj) {
+  /* … */
+ } // ← before the return
+ function methodGetter(obj) {
+  /* … */
+ } // ← before the return
+ if (obj) {
+  return {
+   set: methodSetter(obj),
+   get: methodGetter(obj),
+  };
+ }
 }
 ```
 
@@ -101,12 +107,12 @@ function publicMethods(obj) {
 // Arrow functions and function expressions after return are NOT flagged —
 // use no-unreachable for those.
 function outer() {
-    return 1;
-    const arrow = () => {}; // not a FunctionDeclaration — not flagged here
+ return 1;
+ const arrow = () => {}; // not a FunctionDeclaration — not flagged here
 }
 ```
 
-## Autofix
+## Behavior and migration notes
 
 This rule provides an **autofix**. When triggered, it moves the offending
 `FunctionDeclaration` to immediately before the `ReturnStatement`, preserving
@@ -115,10 +121,25 @@ the correct indentation level.
 When a function declaration has leading comments (including JSDoc), the fixer
 moves those comments together with the declaration.
 
-## Options
-
 This rule has no options.
 
+Original plugin source: [`eslint-plugin-no-function-declare-after-return`](https://github.com/bhumijgupta/eslint-plugin-no-function-declare-after-return).
+
+## ESLint flat config example
+
+```ts
+import etcMisc from "eslint-plugin-etc-misc";
+
+export default [
+ {
+  plugins: { "etc-misc": etcMisc },
+  rules: {
+   "etc-misc/no-function-declare-after-return": "warn",
+  },
+ },
+];
+```
+
 ## When not to use it
 
 - If your team relies on intentional hoisting patterns with thorough documentation,
@@ -132,18 +153,3 @@ This rule has no options.
 
 - [MDN: Function declarations — Hoisting](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function#hoisting)
 - [ESLint built-in: `no-unreachable`](https://eslint.org/docs/rules/no-unreachable)
-
-## ESLint flat config example
-
-```ts
-import etcMisc from "eslint-plugin-etc-misc";
-
-export default [
-    {
-        plugins: { "etc-misc": etcMisc },
-        rules: {
-            "etc-misc/no-function-declare-after-return": "warn",
-        },
-    },
-];
-```

package/docs/rules/no-use-extend-native.md

@@ -2,20 +2,6 @@
 
 Disallow usage of non-native members on built-in JavaScript objects.
 
-## Why this rule is included here
-
-This rule was integrated into `eslint-plugin-etc-misc` to avoid requiring a separate single-rule plugin dependency.
-
-Original plugin source: [`eslint-plugin-no-use-extend-native`](https://github.com/dustinspecker/eslint-plugin-no-use-extend-native).
-
-## Rule details
-
-This rule helps prevent implicit reliance on monkey-patched native prototypes (for example from legacy libraries that add methods like `String.prototype.green`).
-
-Relying on extended native objects can make code unpredictable across runtimes, bundling targets, and dependency versions.
-
-This rule reports member usage on obvious built-in values when the accessed member is not part of the native API.
-
 ## Targeted pattern scope
 
 This rule is intentionally conservative and focuses on obvious built-in object shapes such as:
@@ -27,6 +13,16 @@ This rule is intentionally conservative and focuses on obvious built-in object s
 
 It does **not** attempt full-flow inference for arbitrary identifiers.
 
+## What this rule reports
+
+This rule helps prevent implicit reliance on monkey-patched native prototypes (for example from legacy libraries that add methods like `String.prototype.green`).
+
+This rule reports member usage on obvious built-in values when the accessed member is not part of the native API.
+
+## Why this rule exists
+
+Relying on extended native objects can make code unpredictable across runtimes, bundling targets, and dependency versions.
+
 ## ❌ Incorrect
 
 ```ts
@@ -55,11 +51,11 @@ const value = [].map((entry) => entry);
 const value = String.prototype.toLowerCase.call("ABC");
 ```
 
-## Options
+## Behavior and migration notes
 
 This rule has no options.
 
-## Relationship to ESLint `no-extend-native`
+### Relationship to ESLint `no-extend-native`
 
 - ESLint core [`no-extend-native`](https://eslint.org/docs/latest/rules/no-extend-native) prevents adding properties to native prototypes.
 - This rule prevents consuming non-native members when they appear in code.
@@ -69,15 +65,7 @@ Using both rules together gives better protection:
 1. Prevent introducing prototype extension.
 2. Prevent relying on prototype extension from third-party code.
 
-## When not to use it
-
-- If your project intentionally and explicitly relies on controlled prototype extension.
-- If your runtime environment guarantees specific prototype patches and that dependency is accepted in your architecture.
-
-## Further reading
-
-- [ESLint `no-extend-native`](https://eslint.org/docs/latest/rules/no-extend-native)
-- [MDN: Inheritance and the prototype chain](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain)
+Original plugin source: [`eslint-plugin-no-use-extend-native`](https://github.com/dustinspecker/eslint-plugin-no-use-extend-native).
 
 ## ESLint flat config example
 
@@ -85,11 +73,21 @@ Using both rules together gives better protection:
 import etcMisc from "eslint-plugin-etc-misc";
 
 export default [
-    {
-        plugins: { "etc-misc": etcMisc },
-        rules: {
-            "etc-misc/no-use-extend-native": "error",
-        },
-    },
+ {
+  plugins: { "etc-misc": etcMisc },
+  rules: {
+   "etc-misc/no-use-extend-native": "error",
+  },
+ },
 ];
 ```
+
+## When not to use it
+
+- If your project intentionally and explicitly relies on controlled prototype extension.
+- If your runtime environment guarantees specific prototype patches and that dependency is accepted in your architecture.
+
+## Further reading
+
+- [ESLint `no-extend-native`](https://eslint.org/docs/latest/rules/no-extend-native)
+- [MDN: Inheritance and the prototype chain](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain)

package/docs/rules/no-vulnerable.md

@@ -2,28 +2,24 @@
 
 Disallow regular expressions that are potentially vulnerable to ReDoS (Regular Expression Denial of Service).
 
-## Why this rule is included here
+## Targeted pattern scope
 
-This rule was integrated into `eslint-plugin-etc-misc` to avoid requiring a separate single-rule plugin dependency.
+This rule checks:
 
-Original plugin source: [`eslint-plugin-redos-detector`](https://github.com/tjenkinson/eslint-plugin-redos-detector).
+- `/(...)/flags` literals.
+- `RegExp("...")` and `new RegExp("...", "flags")` when both arguments are statically-known strings.
 
-## Rule details
+This rule intentionally skips dynamic patterns/flags it cannot resolve safely at lint time.
 
-This rule analyzes regular expression literals and statically-resolvable `RegExp(...)` constructor calls using [`recheck`](https://www.npmjs.com/package/recheck).
+## What this rule reports
 
-Catastrophic backtracking can make an application spend excessive CPU time on crafted inputs. In server contexts, that can become an availability issue.
+This rule analyzes regular expression literals and statically-resolvable `RegExp(...)` constructor calls using [`recheck`](https://www.npmjs.com/package/recheck).
 
 This rule reports patterns that `recheck` identifies as vulnerable with polynomial or exponential complexity.
 
-## What this rule checks
-
-This rule checks:
+## Why this rule exists
 
-- `/(...)/flags` literals.
-- `RegExp("...")` and `new RegExp("...", "flags")` when both arguments are statically-known strings.
-
-This rule intentionally skips dynamic patterns/flags it cannot resolve safely at lint time.
+Catastrophic backtracking can make an application spend excessive CPU time on crafted inputs. In server contexts, that can become an availability issue.
 
 ## ❌ Incorrect
 
@@ -50,15 +46,15 @@ const source = getPatternFromConfig();
 const maybeUnsafe = RegExp(source); // Dynamic value: intentionally not analyzed.
 ```
 
-## Options
+## Behavior and migration notes
 
 ```ts
 type Options = [
-    {
-        ignoreErrors?: boolean;
-        permittableComplexities?: Array<"polynomial" | "exponential">;
-        timeout?: number | null;
-    }?,
+ {
+  ignoreErrors?: boolean;
+  permittableComplexities?: Array<"polynomial" | "exponential">;
+  timeout?: number | null;
+ }?,
 ];
 ```
 
@@ -94,6 +90,23 @@ For example, to allow polynomial but still report exponential:
 }
 ```
 
+Original plugin source: [`eslint-plugin-redos-detector`](https://github.com/tjenkinson/eslint-plugin-redos-detector).
+
+## ESLint flat config example
+
+```ts
+import etcMisc from "eslint-plugin-etc-misc";
+
+export default [
+ {
+  plugins: { "etc-misc": etcMisc },
+  rules: {
+   "etc-misc/no-vulnerable": "error",
+  },
+ },
+];
+```
+
 ## When not to use it
 
 - If your codebase never handles untrusted input with regexes.
@@ -105,18 +118,3 @@ For example, to allow polynomial but still report exponential:
 - [OWASP: Regular expression Denial of Service (ReDoS)](https://owasp.org/www-community/attacks/Regular_expression_Denial_of_Service_-_ReDoS)
 - [`recheck` package](https://www.npmjs.com/package/recheck)
 - [MDN: Regular expressions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions)
-
-## ESLint flat config example
-
-```ts
-import etcMisc from "eslint-plugin-etc-misc";
-
-export default [
-    {
-        plugins: { "etc-misc": etcMisc },
-        rules: {
-            "etc-misc/no-vulnerable": "error",
-        },
-    },
-];
-```

package/docs/rules/prefer-includes.md

@@ -19,22 +19,13 @@ comparisons.
 ## ❌ Incorrect
 
 ```ts
-const hasValue =
- [
-  1,
-  2,
-  3,
- ].indexOf(2) !== -1;
+const hasValue = [1, 2, 3].indexOf(2) !== -1;
 ```
 
 ## ✅ Correct
 
 ```ts
-const hasValue = [
- 1,
- 2,
- 3,
-].includes(2);
+const hasValue = [1, 2, 3].includes(2);
 ```
 
 ## Behavior and migration notes

package/docs/rules/presets/all.md

@@ -9,7 +9,7 @@ Use this preset when you want every rule exported by `eslint-plugin-etc-misc`.
 ## Config key
 
 ```ts
-etcMisc.configs.all
+etcMisc.configs.all;
 ```
 
 ## Flat Config example

package/docs/rules/presets/recommended.md

@@ -46,7 +46,7 @@ export default [etcMisc.configs.recommended];
 
 ## Adoption guidance
 
-If you don’t want readonly preference rules yet, start with minimal. Otherwise, start here for a balanced baseline of correctness and maintainability rules. This preset is designed to be a long-term baseline, so it includes some rules that may be initially noisy but are worth fixing early for long-term benefits.
+If you don't want readonly preference rules yet, start with minimal. Otherwise, start here for a balanced baseline of correctness and maintainability rules. This preset is designed to be a long-term baseline, so it includes some rules that may be initially noisy but are worth fixing early for long-term benefits.
 
 This preset now enables a wider "safe baseline" mix:
 

package/docs/rules/require-jsdoc.md

@@ -88,13 +88,7 @@ type Options = [
 ```ts
 [
  {
-  kinds: [
-   "arrow-function",
-   "class",
-   "function",
-   "method",
-   "type",
-  ],
+  kinds: ["arrow-function", "class", "function", "method", "type"],
  },
 ];
 ```

package/docs/rules/sort-array.md

@@ -25,21 +25,13 @@ faster during code review.
 ## ❌ Incorrect
 
 ```ts
-const statuses = [
- "pending",
- "active",
- "archived",
-];
+const statuses = ["pending", "active", "archived"];
 ```
 
 ## ✅ Correct
 
 ```ts
-const statuses = [
- "active",
- "archived",
- "pending",
-];
+const statuses = ["active", "archived", "pending"];
 ```
 
 ## Behavior and migration notes