eslint-plugin-etc-misc 1.0.1

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

@@ -0,0 +1,100 @@
+# no-expression-empty-lines
+
+Disallow blank lines inside expression statements.
+
+## Targeted pattern scope
+
+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,
+blocks, or other statement kinds.
+
+## What this rule reports
+
+This rule reports expression statements whose inner source text contains empty lines and auto-fixes by removing those empty lines.
+
+## Why this rule exists
+
+Blank lines *inside* a single expression usually come from accidental edits and
+make statement boundaries harder to read. Normalizing these expressions reduces
+formatting noise.
+
+## ❌ Incorrect
+
+```ts
+someCall(
+
+    1
+);
+```
+
+## ✅ Correct
+
+```ts
+someCall(
+    1
+);
+```
+
+## Behavior and migration notes
+
+This rule is autofixable.
+
+The fixer removes blank lines inside the expression, trims trailing spaces on
+each line, and rewrites the statement with a terminating semicolon.
+
+### Options
+
+This rule has no options.
+
+## Additional examples
+
+```ts
+doWork(
+    value,
+
+    nextValue
+);
+// ❌ reported
+
+doWork(
+    value,
+    nextValue
+);
+// ✅ valid
+```
+
+## ESLint flat config example
+
+```ts
+import etcMisc from "eslint-plugin-etc-misc";
+
+export default [
+    {
+        plugins: { "etc-misc": etcMisc },
+        rules: {
+            "etc-misc/no-expression-empty-lines": "error",
+        },
+    },
+];
+```
+
+## When not to use it
+
+Disable this rule if blank lines inside expressions are allowed for readability.
+
+## Package documentation
+
+- [eslint-plugin-etc-misc README](https://github.com/Nick2bad4u/eslint-plugin-etc-misc#readme)
+
+> **Rule catalog ID:** R024
+
+## Further reading
+
+- [ESLint: `no-multiple-empty-lines`](https://eslint.org/docs/latest/rules/no-multiple-empty-lines)
+
+## Adoption resources
+
+- Start at warning level in CI, then move to error after cleanup.
+- Use focused codemods/autofix batches per package or directory.

package/docs/rules/no-foreach.md

@@ -0,0 +1,108 @@
+# no-foreach
+
+Disallow calling `forEach` on configured collection types.
+
+## Targeted pattern scope
+
+⚠️ This rule requires type information to run. Configure type-aware linting
+(`parserOptions.project` or `projectService`) before enabling it.
+
+This rule targets member calls to `.forEach(...)` and reports only when the
+receiver type matches configured collection names.
+
+## What this rule reports
+
+This rule reports `.forEach(...)` calls for configured type names (by default: `Array`, `Map`, `NodeList`, and `Set`). In codebases that standardize on explicit loops, `for...of` improves control-flow clarity (for example, with `break`, `continue`, and `return`).
+
+## Why this rule exists
+
+Teams that standardize on explicit loops often prefer `for...of` for control
+flow clarity (`break`, `continue`, early `return`) and debugger ergonomics.
+
+## ❌ Incorrect
+
+```ts
+const answers = [42, 54];
+answers.forEach((answer) => console.log(answer));
+```
+
+## ✅ Correct
+
+```ts
+const answers = [42, 54];
+for (const answer of answers) {
+    console.log(answer);
+}
+```
+
+## Behavior and migration notes
+
+This rule reports only and does not provide an autofix.
+
+Adopt gradually by enabling as `warn`, then migrating hot paths and shared
+utilities to `for...of` before promoting to `error`.
+
+### Options
+
+```ts
+type Options = {
+    types?: string[];
+};
+```
+
+Default: `{ types: ["Array", "Map", "NodeList", "Set"] }`
+
+When `Array` is included, `ReadonlyArray` is also treated as matched.
+
+### `types`
+
+Use this option to control which type names are checked.
+
+## Additional examples
+
+```ts
+const set = new Set([1, 2, 3]);
+set.forEach((value) => console.log(value));
+// ❌ reported with default options
+
+const map = new Map<string, number>();
+for (const [key, value] of map) {
+    console.log(key, value);
+}
+// ✅ preferred style
+```
+
+## ESLint flat config example
+
+```ts
+import etcMisc from "eslint-plugin-etc-misc";
+
+export default [
+    {
+        plugins: { "etc-misc": etcMisc },
+        rules: {
+            "etc-misc/no-foreach": ["error", { types: ["Array", "Set"] }],
+        },
+    },
+];
+```
+
+## When not to use it
+
+Disable this rule if your project intentionally favors iterator callbacks and does not enforce loop-style consistency.
+
+## Package documentation
+
+- [eslint-plugin-etc-misc README](https://github.com/Nick2bad4u/eslint-plugin-etc-misc#readme)
+
+> **Rule catalog ID:** R025
+
+## Further reading
+
+- [MDN: Array.prototype.forEach()](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
+- [MDN: for...of](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/for...of)
+
+## Adoption resources
+
+- Start at warning level in CI, then move to error after cleanup.
+- Use focused codemods/autofix batches per package or directory.

package/docs/rules/no-implicit-any-catch.md

@@ -0,0 +1,159 @@
+# no-implicit-any-catch
+
+Require explicit error parameter typing in Promise rejection callbacks.
+
+## Targeted pattern scope
+
+⚠️ This rule requires type information to run. Configure type-aware linting (`parserOptions.project` or `projectService`) before enabling it.
+
+This rule targets Promise rejection callbacks in:
+
+- `.catch(callback)`
+- `.then(onFulfilled, onRejected)` (second argument)
+
+Only callbacks associated with Promise-like receivers are checked.
+
+## What this rule reports
+
+Promise rejection callbacks often default the error parameter to implicit `any`.
+That weakens type safety and makes unsafe property access easy to miss.
+
+This rule enforces explicit typing for Promise rejection callback parameters in
+`.catch(...)` and the rejection handler position of `.then(...)`.
+
+By default:
+
+- Implicit `any` is reported and auto-fixed to `unknown`.
+- Explicit `any` is reported and auto-fixed to `unknown`.
+- Narrower types (for example `string`) are reported with a safe suggestion to
+  change to `unknown`.
+
+## Why this rule exists
+
+It prevents unsafe assumptions about rejection values and encourages explicit
+narrowing before property access.
+
+## ❌ Incorrect
+
+```ts
+Promise.reject(new Error("Boom")).catch((error) => {
+  console.error(error);
+});
+```
+
+```ts
+Promise.reject(new Error("Boom")).catch((error: any) => {
+  console.error(error);
+});
+```
+
+## ✅ Correct
+
+```ts
+Promise.reject(new Error("Boom")).catch((error: unknown) => {
+  if (error instanceof Error) {
+    console.error(error.message);
+  }
+});
+```
+
+## Behavior and migration notes
+
+This rule is fixable and also provides explicit `suggest` entries.
+
+Automatic fixes annotate missing/`any` parameters as `unknown`. For already
+narrowed annotations, a safe suggestion is provided instead of forced rewrite.
+
+### Options
+
+```ts
+type Options = [
+  {
+    allowExplicitAny?: boolean;
+  }?,
+];
+```
+
+Default:
+
+```ts
+[{}]
+```
+
+### `allowExplicitAny`
+
+Set `allowExplicitAny: true` to allow explicit `any` annotations in Promise
+rejection callbacks.
+
+```ts
+import etcMisc from "eslint-plugin-etc-misc";
+
+export default [
+  {
+    plugins: { "etc-misc": etcMisc },
+    rules: {
+      "etc-misc/no-implicit-any-catch": [
+        "error",
+        {
+          allowExplicitAny: true,
+        },
+      ],
+    },
+  },
+];
+```
+
+## Additional examples
+
+```ts
+Promise.resolve(1).then(
+  (value) => value,
+  (error: string) => {
+    console.error(error);
+  }
+);
+// ❌ reported as narrowed type, with suggestion to use unknown
+
+Promise.resolve(1).catch((error: unknown) => {
+  if (error instanceof Error) {
+    console.error(error.message);
+  }
+});
+// ✅ valid
+```
+
+## ESLint flat config example
+
+```ts
+import etcMisc from "eslint-plugin-etc-misc";
+
+export default [
+    {
+        plugins: { "etc-misc": etcMisc },
+        rules: {
+            "etc-misc/no-implicit-any-catch": "error",
+        },
+    },
+];
+```
+
+## When not to use it
+
+Disable this rule if your codebase intentionally relies on broad rejection
+parameter typing and you do not want to enforce explicit `unknown` handling.
+
+## Package documentation
+
+- [eslint-plugin-etc-misc README](https://github.com/Nick2bad4u/eslint-plugin-etc-misc#readme)
+
+> **Rule catalog ID:** R026
+
+## Further reading
+
+- [TypeScript-ESLint: no-implicit-any-catch](https://typescript-eslint.io/rules/no-implicit-any-catch/)
+- [Catching Unknowns](https://ncjamieson.com/catching-unknowns/)
+
+## Adoption resources
+
+- Start at warning level in CI, then move to error after cleanup.
+- Use focused codemods/autofix batches per package or directory.

package/docs/rules/no-index-import.md

@@ -0,0 +1,101 @@
+# no-index-import
+
+Disallow importing directly from `"."`.
+
+## Targeted pattern scope
+
+This rule inspects module source strings and reports sources that are exactly
+`"."` by default.
+
+## What this rule reports
+
+This rule reports import and export source strings that are exactly `"."`.
+
+## Why this rule exists
+
+Bare `"."` imports often hide barrel/index dependencies and make module
+relationships less explicit.
+
+## ❌ Incorrect
+
+```ts
+import value from ".";
+export { value } from ".";
+```
+
+## ✅ Correct
+
+```ts
+import value from "./feature";
+export { value } from "./feature";
+```
+
+## Behavior and migration notes
+
+This rule reports only and does not provide an autofix.
+
+Migration usually means replacing `"."` with a concrete relative path.
+
+### Options
+
+```ts
+type Options = {
+    allow?: string[];
+    disallow?: string[];
+};
+```
+
+Default:
+
+```json
+{
+    "disallow": ["."]
+}
+```
+
+- `allow`: glob patterns that are exempted.
+- `disallow`: override default disallow patterns.
+
+## Additional examples
+
+```ts
+const moduleRef = await import(".");
+// ❌ reported
+
+const moduleRef = await import("./feature");
+// ✅ valid
+```
+
+## ESLint flat config example
+
+```ts
+import etcMisc from "eslint-plugin-etc-misc";
+
+export default [
+    {
+        plugins: { "etc-misc": etcMisc },
+        rules: {
+            "etc-misc/no-index-import": "error",
+        },
+    },
+];
+```
+
+## When not to use it
+
+Disable this rule if your project intentionally uses `"."` barrel imports.
+
+## Package documentation
+
+- [eslint-plugin-etc-misc README](https://github.com/Nick2bad4u/eslint-plugin-etc-misc#readme)
+
+> **Rule catalog ID:** R027
+
+## Further reading
+
+- [Node.js modules: package entry points](https://nodejs.org/api/packages.html#main)
+
+## Adoption resources
+
+- Start at warning level in CI, then move to error after cleanup.
+- Use focused codemods/autofix batches per package or directory.

package/docs/rules/no-internal-modules.md

@@ -0,0 +1,111 @@
+# no-internal-modules
+
+Disallow importing nested internal module paths.
+
+## Targeted pattern scope
+
+This rule matches import/export sources that look like deep/internal module
+paths, using these default disallow globs:
+
+- `./*/**`
+- `[^@]*/**`
+- `@?*/*/**`
+
+## What this rule reports
+
+This rule reports imports/exports that target internal module segments such as:
+
+- `./folder/internal`
+- `package/internal`
+- `@scope/package/internal`
+
+It allows top-level entry imports such as `./folder`, `package`, and `@scope/package`.
+
+## Why this rule exists
+
+It enforces package entrypoint usage instead of importing deep internal files.
+
+## ❌ Incorrect
+
+```ts
+import a from "./folder/internal";
+import b from "package/internal";
+import c from "@scope/package/internal";
+```
+
+## ✅ Correct
+
+```ts
+import a from "./folder";
+import b from "package";
+import c from "@scope/package";
+```
+
+## Behavior and migration notes
+
+This rule reports only and does not provide an autofix.
+
+Use `allow` to carve out explicit exceptions while migrating toward public
+entrypoint imports.
+
+### Options
+
+```ts
+type Options = {
+    allow?: string[];
+    disallow?: string[];
+};
+```
+
+Default:
+
+```json
+{
+    "disallow": ["./*/**", "[^@]*/**", "@?*/*/**"]
+}
+```
+
+## Additional examples
+
+```ts
+// default disallow includes "@?*/*/**"
+import c from "@scope/package/internal/file";
+// ❌ reported
+
+import c from "@scope/package";
+// ✅ valid
+```
+
+## ESLint flat config example
+
+```ts
+import etcMisc from "eslint-plugin-etc-misc";
+
+export default [
+    {
+        plugins: { "etc-misc": etcMisc },
+        rules: {
+            "etc-misc/no-internal-modules": "error",
+        },
+    },
+];
+```
+
+## When not to use it
+
+Disable this rule if your project intentionally imports deep internal module paths.
+
+## Package documentation
+
+- [eslint-plugin-etc-misc README](https://github.com/Nick2bad4u/eslint-plugin-etc-misc#readme)
+
+> **Rule catalog ID:** R029
+
+## Further reading
+
+- [Node.js package exports](https://nodejs.org/api/packages.html#exports)
+
+## Adoption resources
+
+- Start at warning level in CI, then move to error after cleanup.
+- Use focused codemods/autofix batches per package or directory.